/**
* Not exactly the same as the executor's definition of getFieldDef, in this
* statically evaluated environment we do not always have an Object type,
* and need to handle Interface and Union types.
*
* @param Schema $schema
* @param Type $parentType
* @param Field $fieldAST
*
* @return FieldDefinition
*/
protected static function getFieldDefinition(Schema $schema, Type $parentType, Field $fieldAST)
{
$name = $fieldAST->get('name')->get('value');
$schemaMeta = Introspection::schemaMetaFieldDefinition();
if ($name === $schemaMeta->getName() && $schema->getQueryType() === $parentType) {
return $schemaMeta;
}
$typeMeta = Introspection::typeMetaFieldDefinition();
if ($name === $typeMeta->getName() && $schema->getQueryType() === $parentType) {
return $typeMeta;
}
$typeNameMeta = Introspection::typeNameMetaFieldDefinition();
if ($name === $typeNameMeta->getName() && ($parentType instanceof ObjectType || $parentType instanceof InterfaceType || $parentType instanceof UnionType)) {
return $typeNameMeta;
}
if ($parentType instanceof ObjectType || $parentType instanceof InterfaceType) {
$fields = $parentType->getFields();
return isset($fields[$name]) ? $fields[$name] : NULL;
}
return NULL;
}
/**
* @param $a
* @param array $args
* @param $b
* @param $c
* @param $d
* @param $e
* @param \Fubhy\GraphQL\Schema $schema
* @return \Fubhy\GraphQL\Type\Definition\Types\TypeInterface
*/
public static function resolveTypeMetaField($a, array $args, $b, $c, $d, $e, Schema $schema)
{
return $schema->getType($args['name']);
}
public function testIncludesInterfacesSubtypesInTheTypeMap()
{
$someInterface = new InterfaceType('SomeInterface');
$someSubType = new ObjectType('SomeSubType', [], [$someInterface]);
$schema = new Schema($someInterface);
$this->assertSame($someSubType, $schema->getTypeMap()['SomeSubType']);
}
/**
* This method looks up the field on the given type defintion.
* It has special casing for the two introspection fields, __schema
* and __typename. __typename is special because it can always be
* queried as a field, even in situations where no other fields
* are allowed, like on a Union. __schema could get automatically
* added to the query type, but that would require mutating type
* definitions, which would cause issues.
*
* @param Schema $schema
* @param ObjectType $parent
* @param Field $ast
*
* @return FieldDefinition
*/
protected static function getFieldDefinition(Schema $schema, ObjectType $parent, Field $ast)
{
$name = $ast->get('name')->get('value');
$schemaMeta = Introspection::schemaMetaFieldDefinition();
$typeMeta = Introspection::typeMetaFieldDefinition();
$typeNameMeta = Introspection::typeNameMetaFieldDefinition();
if ($name === $schemaMeta->getName() && $schema->getQueryType() === $parent) {
return $schemaMeta;
} else {
if ($name === $typeMeta->getName() && $schema->getQueryType() === $parent) {
return $typeMeta;
} else {
if ($name === $typeNameMeta->getName()) {
return $typeNameMeta;
}
}
}
$tmp = $parent->getFields();
return isset($tmp[$name]) ? $tmp[$name] : NULL;
}
