Package io.smallrye.graphql.api

Interface Context

  • @Experimental("Request context to allow downstream operations to get insight into the request. Not covered by the specification. Subject to change.")
public interface Context
    Holing context for the current request There are two parts to this.The initial request, that can be a aggregation of requests, and the current execution context.
    Author:
    Phillip Kruger ([email protected])

    • Method Detail

      • getRequest

        jakarta.json.JsonObject getRequest()
        Get the full body of the request. This includes the query, variables and operation name
        Returns:
        JsonObject

      • hasRequest

        default boolean hasRequest()
        Check if there is a request set
        Returns:

      • getQuery

        default String getQuery()
        Get the query part of the request. TODO: Consider creating a domain object for this (rather than String).
        Returns:
        raw string query

      • getOperationName

        Optional<String> getOperationName()
        Get the operationName of the request. Could be null (not set)
        Returns:
        the operation name if set

      • hasOperationName

        default boolean hasOperationName()
        Check if the request contains an operation name
        Returns:
        true if it does

      • getVariables

        default Optional<Map<String,​Object>> getVariables()
        Get the variables of the request Could be null (not set)
        Returns:

      • hasVariables

        default boolean hasVariables()
        Check if the request contains variables
        Returns:
        true if it does

      • getExecutionId

        String getExecutionId()
        Get the execution ID.
        Returns:
        the ID as a String

      • getFieldName

        String getFieldName()
        Get the field name
        Returns:
        name of the field

      • hasArgument

        default <A> Boolean hasArgument​(String name)
        Return true if the argument exist
        Parameters:
        name - the argument name
        Returns:
        true if there

      • getArgument

        default <A> A getArgument​(String name)
        Get the argument using a name This return the argument instance if it exists
        Parameters:
        name - key
        Returns:
        argument value

      • getArgumentOrDefault

        default <A> A getArgumentOrDefault​(String name,
                                   A defaultValue)
        Same as above but with the option to do a default value
        Parameters:
        name -
        defaultValue -
        Returns:
        the argument instance if it exists, else the provided default

      • getArguments

        <A> Map<String,​A> getArguments()
        Get all the arguments
        Returns:
        a map with name and instance of the argument

      • hasSource

        default boolean hasSource()

      • getSource

        <S> S getSource()

      • getPath

        String getPath()
        Return the current path
        Returns:
        the path as a String

      • getSelectedFields

        jakarta.json.JsonArray getSelectedFields()
        Return the fields selected in the request
        Returns:
        JsonArray of fields selected

      • getSelectedAndSourceFields

        jakarta.json.JsonArray getSelectedAndSourceFields()
        Return the fields and source fields in the request
        Returns:
        JsonArray of fields selected

      • getOperationType

        String getOperationType()
        Return the current type (Query, Mutation ext) Current type means the type currently being executed.
        Returns:
        name of the operation type

      • getRequestedOperationTypes

        List<String> getRequestedOperationTypes()
        Return all the operation types requested (unique list) A Request can contain more than one operation. This will return a unique list of types. So if there is 2 Queries, it will only return one QUERY type, but if there is two queries and a mutation, it will return QUERY,MUTATION
        Returns:

      • getParentTypeName

        Optional<String> getParentTypeName()
        Return the type name of the parent (if any)
        Returns:
        the parent type name maybe

      • unwrap

        <T> T unwrap​(Class<T> wrappedType)
        This leaky abstraction allows falling down to the underlying implementation
        Type Parameters:
        T - the implementation class
        Parameters:
        wrappedType - the class type of T
        Returns:
        instance of the implementation class