`Schema::getType()` shoud always return `null` for non-existent type

[vhenzl]

There is an inconsistency in how Schema::getType() behaves depending on how the schema is created.

If the schema is created using type definitions, it correctly returns null for a type that doesn't exist in the schema:

$schema = new Schema([
    'types' => [
        new ObjectType([
            'name' => 'Foo',
            'fields' => ['id' => Type::id()],
        ]),
    ],
]);

$foo = $schema->getType('Foo');
$bar = $schema->getType('Bar'); // ✅ returns null as expected

If the schema is built from SDL, it throws Unknown type: "Bar". error instead or returning null:

$schema = BuildSchema::build('type Foo { id: ID }');

$foo = $schema->getType('Foo');
$bar = $schema->getType('Bar'); // 💥 throws error

This has a negative impact for example on SDL validation rules.

For reference, graphql-js always returns undefined for a non-existent type, regardless of how the schema was created.

I'm trying to wrap my head around how the lazy type loading works (it seems related, at least partially). Any suggestions on how to fix this without a significant rewrite of BuildSchema, SchemaExtender and ASTDefinitionBuilder are welcome. (However, I'm hitting various problems with schema building & extending from different directions, so I'm more and more convinced that rewriting them in accordance with the reference implementation is actually the only reasonable solution.)

[spawnia]

Relates to #964 (comment)

I'm trying to wrap my head around how the lazy type loading works

It all happens in Schema. One important part is where the actual lazy loading happens:

graphql-php/src/Type/Schema.php

Lines 295 to 306 in 647e2cf

	if (! isset($this->resolvedTypes[$name])) {
	$type = Type::getStandardTypes()[$name]
	?? $this->loadType($name);
	if ($type === null) {
	return null;
	}
	$this->resolvedTypes[$name] = self::resolveType($type);
	}
	return $this->resolvedTypes[$name];

However, loading types simply on demand would be problematic. Suppose a schema is constructed from SDL and a lazy loader is provided, how would validation/introspection be able to load all existing types? That's why there is an additional method that allows loading all types, by providing a callable to the types option:

graphql-php/src/Type/Schema.php

Lines 150 to 168 in 647e2cf

	private function resolveAdditionalTypes(): Generator
	{
	$types = $this->config->types;
	if (is_callable($types)) {
	$types = $types();
	}
	// @phpstan-ignore-next-line not strictly enforced unless PHP supports function types
	if (! is_iterable($types)) {
	$notIterable = Utils::getVariableType($types);
	throw new InvariantViolation("Schema types callable must return iterable but got: {$notIterable}");
	}
	foreach ($types as $type) {
	yield self::resolveType($type);
	}
	}

[vhenzl]

Sorry for the long silence; haven't got much time recently…

#1038 that allowed type loaders to return null was a step in the correct direction.

Essentially, everything necessary to fix this problem now is to allow the type loader created in BuildSchema to return null if the loaded type isn't defined in the SDL schema:

https://github.com/webonyx/graphql-php/blob/master/src/Utils/BuildSchema.php#L209

I'll prepare a PR.