typeNameMetaFieldDef() public static method

public static typeNameMetaFieldDef ( )
Beispiel #1
0
 /**
  * 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.
  *
  * @return FieldDefinition
  */
 private static function _getFieldDef(Schema $schema, Type $parentType, Field $fieldAST)
 {
     $name = $fieldAST->name->value;
     $schemaMeta = Introspection::schemaMetaFieldDef();
     if ($name === $schemaMeta->name && $schema->getQueryType() === $parentType) {
         return $schemaMeta;
     }
     $typeMeta = Introspection::typeMetaFieldDef();
     if ($name === $typeMeta->name && $schema->getQueryType() === $parentType) {
         return $typeMeta;
     }
     $typeNameMeta = Introspection::typeNameMetaFieldDef();
     if ($name === $typeNameMeta->name && ($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;
 }
Beispiel #2
0
 /**
  * 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 $parentType
  * @param $fieldName
  *
  * @return FieldDefinition
  */
 private static function getFieldDef(Schema $schema, ObjectType $parentType, $fieldName)
 {
     static $schemaMetaFieldDef, $typeMetaFieldDef, $typeNameMetaFieldDef;
     $schemaMetaFieldDef = $schemaMetaFieldDef ?: Introspection::schemaMetaFieldDef();
     $typeMetaFieldDef = $typeMetaFieldDef ?: Introspection::typeMetaFieldDef();
     $typeNameMetaFieldDef = $typeNameMetaFieldDef ?: Introspection::typeNameMetaFieldDef();
     if ($fieldName === $schemaMetaFieldDef->name && $schema->getQueryType() === $parentType) {
         return $schemaMetaFieldDef;
     } else {
         if ($fieldName === $typeMetaFieldDef->name && $schema->getQueryType() === $parentType) {
             return $typeMetaFieldDef;
         } else {
             if ($fieldName === $typeNameMetaFieldDef->name) {
                 return $typeNameMetaFieldDef;
             }
         }
     }
     $tmp = $parentType->getFields();
     return isset($tmp[$fieldName]) ? $tmp[$fieldName] : null;
 }
 /**
  * Given a selectionSet, adds all of the fields in that selection to
  * the passed in map of fields, and returns it at the end.
  *
  * Note: This is not the same as execution's collectFields because at static
  * time we do not know what object type will be used, so we unconditionally
  * spread in all fragments.
  *
  * @see GraphQL\Validator\Rules\OverlappingFieldsCanBeMerged
  *
  * @param ValidationContext $context
  * @param Type|null         $parentType
  * @param SelectionSetNode      $selectionSet
  * @param \ArrayObject      $visitedFragmentNames
  * @param \ArrayObject      $astAndDefs
  *
  * @return \ArrayObject
  */
 protected function collectFieldASTsAndDefs(ValidationContext $context, $parentType, SelectionSetNode $selectionSet, \ArrayObject $visitedFragmentNames = null, \ArrayObject $astAndDefs = null)
 {
     $_visitedFragmentNames = $visitedFragmentNames ?: new \ArrayObject();
     $_astAndDefs = $astAndDefs ?: new \ArrayObject();
     foreach ($selectionSet->selections as $selection) {
         switch ($selection->kind) {
             case NodeKind::FIELD:
                 /* @var FieldNode $selection */
                 $fieldName = $selection->name->value;
                 $fieldDef = null;
                 if ($parentType && method_exists($parentType, 'getFields')) {
                     $tmp = $parentType->getFields();
                     $schemaMetaFieldDef = Introspection::schemaMetaFieldDef();
                     $typeMetaFieldDef = Introspection::typeMetaFieldDef();
                     $typeNameMetaFieldDef = Introspection::typeNameMetaFieldDef();
                     if ($fieldName === $schemaMetaFieldDef->name && $context->getSchema()->getQueryType() === $parentType) {
                         $fieldDef = $schemaMetaFieldDef;
                     } elseif ($fieldName === $typeMetaFieldDef->name && $context->getSchema()->getQueryType() === $parentType) {
                         $fieldDef = $typeMetaFieldDef;
                     } elseif ($fieldName === $typeNameMetaFieldDef->name) {
                         $fieldDef = $typeNameMetaFieldDef;
                     } elseif (isset($tmp[$fieldName])) {
                         $fieldDef = $tmp[$fieldName];
                     }
                 }
                 $responseName = $this->getFieldName($selection);
                 if (!isset($_astAndDefs[$responseName])) {
                     $_astAndDefs[$responseName] = new \ArrayObject();
                 }
                 // create field context
                 $_astAndDefs[$responseName][] = [$selection, $fieldDef];
                 break;
             case NodeKind::INLINE_FRAGMENT:
                 /* @var InlineFragmentNode $selection */
                 $_astAndDefs = $this->collectFieldASTsAndDefs($context, TypeInfo::typeFromAST($context->getSchema(), $selection->typeCondition), $selection->selectionSet, $_visitedFragmentNames, $_astAndDefs);
                 break;
             case NodeKind::FRAGMENT_SPREAD:
                 /* @var FragmentSpreadNode $selection */
                 $fragName = $selection->name->value;
                 if (empty($_visitedFragmentNames[$fragName])) {
                     $_visitedFragmentNames[$fragName] = true;
                     $fragment = $context->getFragment($fragName);
                     if ($fragment) {
                         $_astAndDefs = $this->collectFieldASTsAndDefs($context, TypeInfo::typeFromAST($context->getSchema(), $fragment->typeCondition), $fragment->selectionSet, $_visitedFragmentNames, $_astAndDefs);
                     }
                 }
                 break;
         }
     }
     return $_astAndDefs;
 }