Introspection - Interfaces and empty possible types

[chrissm79]

When sending up a introspection query I am getting "possibleTypes" =>[] on my interfaces. My ObjectTypes define their interfaces w/ a callback and the interfaces themselves resolve just fine on a regular query. It's just when sending up the following introspection query it always provides a empty array value for interfaces.

{
    __schema {
        types {
            kind
            name
            possibleTypes {
                name
            }
        }
    }
}

(I also noticed that the callback defined in the setTypeLoader of the SchemaConfig is never called.. not sure if it should be or not but I figured it would do so to try and get the interfaces for each defined type)

[chrissm79]

Test

/**
  * @see it('gets execution info in resolver')
  */
public function testCallsObjectTypeInterfaceCallback() : void
{
    $NamedType2 = new InterfaceType([
        'name'        => 'Named',
        'fields'      => [
            'name' => ['type' => Type::string()],
        ],
        'resolveType' => function (
            $obj,
            $context,
            ResolveInfo $info
        ) use (&$PersonType2) {
            return $PersonType2;
        },
    ]);

    $PersonType2 = new ObjectType([
        'name'       => 'Person',
        'interfaces' => function () use ($NamedType2) {
            return [$NamedType2];
        },
        'fields'     => [
            'name'    => ['type' => Type::string()],
            'friends' => ['type' => Type::listOf($NamedType2)],
        ],
    ]);

    $QueryType = new ObjectType([
        'name' => 'Query',
        'fields' => [
            'named' => [
                'type' => $NamedType2,
                'resolve' => function () use (&$NamedType2) {
                    return $NamedType2;
                }
            ]
        ]
    ]);

    $config = \GraphQL\Type\SchemaConfig::create()
        ->setQuery($QueryType)
        ->setTypeLoader(function ($name) use (&$QueryType, &$NamedType2, &$PersonType2) {
            switch ($name) {
                case 'Query':
                    return $QueryType;
                case 'Named':
                    return $NamedType2;
                case 'Person':
                    return $PersonType2;
            }
        });

    $schema2 = new Schema($config);

    $ast = Parser::parse('{
        __schema {
            types {
                kind
                name
                possibleTypes {
                    name
                }
            }
        }
    }');

    $result = GraphQL::executeQuery($schema2, $ast)->toArray();
    $interface = current(array_filter(
        $result['data']['__schema']['types'],
        function ($type) {
            return $type['name'] === 'Named' && $type['kind'] === 'INTERFACE';
        }
    ));
    
    $this->assertCount(1, $interface['possibleTypes']);
}

Note: This may just be an issue when using the SchemaConfig class rather than defining the Schema with an array config.

[spawnia]

I dug a little further into the code and found the root cause.

You can reproduce it with a schema like this and by using a typeLoader to lazily resolve the types.

	interface Nameable {
    	name: String!
    }
    
    type User implements Nameable {
        name: String!
    }
    
    type Query {
        namedThings: [Nameable!]!
		# It does not find the User type if this is not present
        # user: User
    }

GraphQL\Utils\TypeInfo::resolveInfo() is responsible for walking through a schema and recursively finding all types that are used. It does not find the User type if it is not explicitely used in a Query. And honestly, i do not have a clue how it might do that.

[vladar]

@spawnia You are right - it can't. That's why we have types option in the schema config.

It is the only way to discover such orphan types.

[vladar]

@chrissm79 Please let me know if it works for you.

[chrissm79]

Thanks for the feedback @vladar!! I can just set up a config option in our package to switch over to using the types option if needed which would resolve this issue.

[spawnia]

@chrissm79 I think the easiest fix for us is just to pass in the types directly. It is not like our type registry is doing any actual lazy type loading, so we do not lose out in terms of performance.

Let's just use the Schema directly instead of the TypeRegistry. At least that will avoid duplicating the information in two classes when it is really the same. I will prepare a PR for it!

[vladar]

As far as I remember types can also be a closure. It is called after every other method of type loading. This way you can diff the list of types loaded with your typeLoader against the list of all types (I assume you have it from AST) and return only those types that were not loaded with typeLoader.

We were doing it previously in BuildSchema.