[Support] How to get AST from extended Schema

[Kingdutch]

The library recommends storing the parsed AST on disk as a loadable PHP file that can be loaded and passed to BuildSchema::build which generates a lazy-loaded schema. However this causes challenges when combined with a set-up that makes use of extend type.

Below are the two non-ideal methods that I know of, one doesn't work and another has a transformation that feels unnecessary. What is the correct way to do AST::toArray($schema) to allow restoring a merged schema later with AST::fromArray?

Storing the concatenated parsed AST
One option which seems sensible is to parse all individual documents and use AST::concatAST over the array. This results in a merged AST that could be passed to BuildSchema::buildAst. The problem is that BuildSchema::buildSchema does not handle extend type nodes, so this results in a schema that only has the base fields.

Using SchemaExtender::extend
This is the preferred method to apply these kinds of extensions. Fetching the AST that contains the extension separately is easy enough and it's even possible to cache this to disk with AST::toArray. However the method itself will load all types in the schema that's being extended which is a very slow operation, so this makes it unusable in production.

The goal is then to get a resulting AST from the merged schema. The only way that I'm aware of to get an AST from a schema and write it to disk is to run AST::toArray(Parser::parse(SchemaPrinter::doPrint($schema))). However it feels weird to go through text this way and not being able to get the AST from the schema directly without going through SDL.

[spawnia]

How about you merge the extend type nodes on the AST level and store the result? I don't think there is a utility for that, but it should not be that hard to build one. We might even consider inclusion in this library.

[Kingdutch]

This is what I tried and described in "Storing the concatenated parsed AST", or I'm missing how your suggestion is different.

AST::concatAST works great to do it, but the problem is that there's no way to "hydrate" that AST from disk because BuildSchema::buildSchema itself ignores the extend directives and only looks at the type declarations itself.

Or do you mean "merge the extend directives to normal directives on the AST level"? That's basically what SchemaExtender::extend does, but I don't know how to get the AST transformation that it does out of the schema (and I don't want to duplicate the work that it does).

[spawnia]

I mean a function that takes an AST such as this:

type Foo {
  a: Int
}

extend type Foo {
  b: Int
}

...and turns it into an AST such as this:

type Foo {
  a: Int
  b: Int
}

SchemaExtender::extend does not do this, it works with an executable schema. As mentioned, no existing utility does this.

I am confused why you are now mentioning directives in your answer, what is the deal with that?

[Kingdutch]

Ah I think we're running into the limits of my knowledge of the library here :D

SchemaExtender::extend does not do this, it works with an executable schema. As mentioned, no existing utility does this.

I did not know the executable schema was separate from the other AST, I thought it was the same :D

I am confused why you are now mentioning directives in your answer, what is the deal with that?

Sorry, this was my brain confusing concepts I meant to write definition. I misremembered from looking at the BuildSchema class and remembered the DirectiveDefinitionNode which is separate.

I'll see if I can figure out how to make something such as "Flatten schema" in the way you described :D