Package graphql.normalized.nf

Class NormalizedField

java.lang.Object
graphql.normalized.nf.NormalizedField
@ExperimentalApi public class NormalizedField extends Object
An NormalizedField represents a field in an executable graphql operation. Its models what could be executed during a given operation.

This class is intentionally mutable for performance reasons since building immutable parent child objects is too expensive.

  • Method Details

    • isConditional

      public boolean isConditional(@NonNull GraphQLSchema schema)
      Determines whether this NormalizedField needs a fragment to select the field. However, it considers the parent output type when determining whether it needs a fragment.

      Consider the following schema 

       interface Animal {
     name: String
     parent: Animal
 }
 type Cat implements Animal {
     name: String
     parent: Cat
 }
 type Dog implements Animal {
     name: String
     parent: Dog
     isGoodBoy: Boolean
 }
 type Query {
     animal: Animal
 }

      and the following query 

       {
     animal {
         parent {
             name
         }
     }
 }

      Then we would get the following ExecutableNormalizedOperation 

       -Query.animal: Animal
 --[Cat, Dog].parent: Cat, Dog
 ---[Cat, Dog].name: String

      If we simply checked the parent's getFieldDefinitions(GraphQLSchema) that would point us to Cat.parent and Dog.parent whose output types would incorrectly answer our question whether this is conditional?

      We MUST consider that the output type of the parent field is Animal and NOT Cat or Dog as their respective implementations would say.

      Parameters:
      schema - - the graphql schema in play
      Returns:
      true if the field is conditional

    • hasChildren

      public boolean hasChildren()

    • getType

      public GraphQLOutputType getType(GraphQLSchema schema)

    • getTypes

      public List<GraphQLOutputType> getTypes(GraphQLSchema schema)

    • forEachFieldDefinition

      public void forEachFieldDefinition(GraphQLSchema schema, Consumer<GraphQLFieldDefinition> consumer)

    • getFieldDefinitions

      public List<GraphQLFieldDefinition> getFieldDefinitions(GraphQLSchema schema)

    • addObjectTypeNames

      public void addObjectTypeNames(Collection<String> objectTypeNames)

    • setObjectTypeNames

      public void setObjectTypeNames(Collection<String> objectTypeNames)

    • addChild

      public void addChild(NormalizedField normalizedField)

    • clearChildren

      public void clearChildren()

    • getName

      public String getName()
      All merged fields have the same name so this is the name of the NormalizedField.

      WARNING: This is not always the key in the execution result, because of possible field aliases.

      Returns:
      the name of this NormalizedField
      See Also:

    • getFieldName

      public String getFieldName()
      Returns:
      the same value as getName()
      See Also:

    • getResultKey

      public String getResultKey()
      Returns the result key of this NormalizedField within the overall result. This is either a field alias or the value of getName()
      Returns:
      the result key for this NormalizedField.
      See Also:

    • getAlias

      public String getAlias()
      Returns:
      the field alias used or null if there is none
      See Also:

    • getAstArguments

      public com.google.common.collect.ImmutableList<Argument> getAstArguments()
      Returns:
      a list of the Arguments on the field

    • getAstDirectives

      public List<Directive> getAstDirectives()

    • setAstDirectives

      public void setAstDirectives(List<Directive> astDirectives)

    • getNormalizedArgument

      public NormalizedInputValue getNormalizedArgument(String name)
      Returns an argument value as a NormalizedInputValue which contains its type name and its current value
      Parameters:
      name - the name of the argument
      Returns:
      an argument value

    • getNormalizedArguments

      public com.google.common.collect.ImmutableMap<String,NormalizedInputValue> getNormalizedArguments()
      Returns:
      a map of all the arguments in NormalizedInputValue form

    • getResolvedArguments

      public LinkedHashMap<String,Object> getResolvedArguments()
      Returns:
      a map of the resolved argument values

    • getObjectTypeNames

      public Set<String> getObjectTypeNames()
      A NormalizedField can sometimes (for non-concrete types like interfaces and unions) have more than one object type it could be when executed. There is no way to know what it will be until the field is executed over data and the type is resolved via a TypeResolver.

      This method returns all the possible types a field can be which is one or more GraphQLObjectType names.

      Warning: This returns a Mutable Set. No defensive copy is made for performance reasons.

      Returns:
      a set of the possible type names this field could be.

    • getSingleObjectTypeName

      public String getSingleObjectTypeName()
      This returns the first entry in getObjectTypeNames(). Sometimes you know a field cant be more than one type and this method is a shortcut one to help you.
      Returns:
      the first entry from

    • printDetails

      public String printDetails()
      Returns:
      a helper method show field details

    • objectTypeNamesToString

      public String objectTypeNamesToString()
      Returns:
      a helper method to show the object types names as a string

    • getListOfResultKeys

      public List<String> getListOfResultKeys()
      This returns the list of the result keys (see getResultKey() that lead from this field upwards to its parent field
      Returns:
      a list of the result keys from this NormalizedField to the top of the operation via parent fields

    • getChildren

      public List<NormalizedField> getChildren()
      Returns:
      the children of the NormalizedField

    • getChildrenWithSameResultKey

      public List<NormalizedField> getChildrenWithSameResultKey(String resultKey)
      Returns the list of child fields that would have the same result key
      Parameters:
      resultKey - the result key to check
      Returns:
      a list of all direct NormalizedField children with the specified result key

    • getChildren

      public List<NormalizedField> getChildren(int includingRelativeLevel)

    • getChildren

      public List<NormalizedField> getChildren(String objectTypeName)
      This returns the child fields that can be used if the object is of the specified object type
      Parameters:
      objectTypeName - the object type
      Returns:
      a list of child fields that would apply to that object type

    • getLevel

      public int getLevel()
      the level of the NormalizedField in the operation hierarchy with top level fields starting at 1
      Returns:
      the level of the NormalizedField in the operation hierarchy

    • getParent

      public NormalizedField getParent()
      Returns:
      the parent of this NormalizedField or null if it's a top level field

    • replaceParent

      public void replaceParent(NormalizedField newParent)

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • traverseSubTree

      public void traverseSubTree(Consumer<NormalizedField> consumer)
      Traverse from this NormalizedField down into itself and all of its children
      Parameters:
      consumer - the callback for each NormalizedField in the hierarchy.

    • newNormalizedField

      public static NormalizedField.Builder newNormalizedField()
      Returns:
      a NormalizedField.Builder of NormalizedFields

    • transform

      public NormalizedField transform(Consumer<NormalizedField.Builder> builderConsumer)
      Allows this NormalizedField to be transformed via a NormalizedField.Builder consumer callback
      Parameters:
      builderConsumer - the consumer given a builder
      Returns:
      a new transformed NormalizedField