Class: GraphQL::Query

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/graphql/query.rb,
lib/graphql/query/context.rb,
lib/graphql/query/executor.rb,
lib/graphql/query/arguments.rb,
lib/graphql/query/variables.rb,
lib/graphql/query/null_context.rb,
lib/graphql/query/literal_input.rb,
lib/graphql/query/arguments_cache.rb,
lib/graphql/query/serial_execution.rb,
lib/graphql/query/validation_pipeline.rb,
lib/graphql/query/input_validation_result.rb,
lib/graphql/query/variable_validation_error.rb,
lib/graphql/query/serial_execution/field_resolution.rb,
lib/graphql/query/serial_execution/value_resolution.rb,
lib/graphql/query/serial_execution/operation_resolution.rb,
lib/graphql/query/serial_execution/selection_resolution.rb

Overview

A combination of query string and Schema instance which can be reduced to a #result.

Defined Under Namespace

Modules: ArgumentsCache Classes: Arguments, Context, Executor, InputValidationResult, LiteralInput, NullContext, OperationNameMissingError, SerialExecution, ValidationPipeline, VariableValidationError, Variables

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil) ⇒ Query

Prepare query query_string on schema

Parameters:

  • schema (GraphQL::Schema)
  • query_string (String) (defaults to: nil)
  • context (#[]) (defaults to: nil) —

    an arbitrary hash of values which you can access in Field#resolve

  • variables (Hash) (defaults to: {}) —

    values for $variables in the query

  • operation_name (String) (defaults to: nil) —

    if the query string contains many operations, this is the one which should be executed

  • root_value (Object) (defaults to: nil) —

    the object used to resolve fields on the root type

  • max_depth (Numeric) (defaults to: nil) —

    the maximum number of nested selections allowed for this query (falls back to schema-level value)

  • max_complexity (Numeric) (defaults to: nil) —

    the maximum field complexity for this query (falls back to schema-level value)

  • except (<#call(schema_member, context)>) (defaults to: nil) —

    If provided, objects will be hidden from the schema when .call(schema_member, context) returns truthy

  • only (<#call(schema_member, context)>) (defaults to: nil) —

    If provided, objects will be hidden from the schema when .call(schema_member, context) returns false



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/graphql/query.rb', line 43

def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
  fail ArgumentError, "a query string or document is required" unless query_string || document

  @schema = schema
  mask = GraphQL::Schema::Mask.combine(schema.default_mask, except: except, only: only)
  @context = Context.new(query: self, values: context)
  @warden = GraphQL::Schema::Warden.new(mask, schema: @schema, context: @context)
  @root_value = root_value
  @fragments = {}
  @operations = {}
  if variables.is_a?(String)
    raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
  else
    @provided_variables = variables
  end
  @query_string = query_string
  parse_error = nil
  @document = document || begin
    GraphQL.parse(query_string)
  rescue GraphQL::ParseError => err
    parse_error = err
    @schema.parse_error(err, @context)
    nil
  end

  @document && @document.definitions.each do |part|
    case part
    when GraphQL::Language::Nodes::FragmentDefinition
      @fragments[part.name] = part
    when GraphQL::Language::Nodes::OperationDefinition
      @operations[part.name] = part
    end
  end

  @resolved_types_cache = Hash.new { |h, k| h[k] = @schema.resolve_type(k, @context) }

  @arguments_cache = ArgumentsCache.build(self)

  # Trying to execute a document
  # with no operations returns an empty hash
  @ast_variables = []
  @mutation = false
  operation_name_error = nil
  if @operations.any?
    @selected_operation = find_operation(@operations, operation_name)
    if @selected_operation.nil?
      operation_name_error = GraphQL::Query::OperationNameMissingError.new(operation_name)
    else
      @ast_variables = @selected_operation.variables
      @mutation = @selected_operation.operation_type == "mutation"
    end
  end

  @validation_pipeline = GraphQL::Query::ValidationPipeline.new(
    query: self,
    parse_error: parse_error,
    operation_name_error: operation_name_error,
    max_depth: max_depth || schema.max_depth,
    max_complexity: max_complexity || schema.max_complexity,
  )

  @result = nil
  @executed = false
end

Instance Attribute Details

#context ⇒ Object (readonly)

Returns the value of attribute context.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def context
  @context
end

#document ⇒ Object (readonly)

Returns the value of attribute document.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def document
  @document
end

#fragments ⇒ Object (readonly)

Returns the value of attribute fragments.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def fragments
  @fragments
end

#operations ⇒ Object (readonly)

Returns the value of attribute operations.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def operations
  @operations
end

#provided_variables ⇒ Object (readonly)

Returns the value of attribute provided_variables.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def provided_variables
  @provided_variables
end

#query_string ⇒ Object (readonly)

Returns the value of attribute query_string.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def query_string
  @query_string
end

#root_value ⇒ Object (readonly)

Returns the value of attribute root_value.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def root_value
  @root_value
end

#schema ⇒ Object (readonly)

Returns the value of attribute schema.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def schema
  @schema
end

#selected_operation ⇒ GraphQL::Language::Nodes::Document? (readonly)

Returns:



138
139
140
 
# File 'lib/graphql/query.rb', line 138

def selected_operation
  @selected_operation
end

#warden ⇒ Object (readonly)

Returns the value of attribute warden.



30
31
32
 
# File 'lib/graphql/query.rb', line 30

def warden
  @warden
end

Instance Method Details

#arguments_for(irep_or_ast_node, definition) ⇒ GraphQL::Query::Arguments

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Node-level cache for calculating arguments. Used during execution and query analysis.

Returns:



164
165
166
 
# File 'lib/graphql/query.rb', line 164

def arguments_for(irep_or_ast_node, definition)
  @arguments_cache[irep_or_ast_node][definition]
end

#irep_selection ⇒ Object 



157
158
159
 
# File 'lib/graphql/query.rb', line 157

def irep_selection
  @selection ||= internal_representation[selected_operation.name]
end

#mutation? ⇒ Boolean

Returns:

  • (Boolean) 


182
183
184
 
# File 'lib/graphql/query.rb', line 182

def mutation?
  @mutation
end

#resolve_type(value) ⇒ GraphQL::ObjectType?

Returns The runtime type of value from Schema#resolve_type.

Parameters:

  • value (Object) —

    Any runtime value

Returns:

See Also:

  • to apply filtering from `only` / `except`


178
179
180
 
# File 'lib/graphql/query.rb', line 178

def resolve_type(value)
  @resolved_types_cache[value]
end

#result ⇒ Hash

Get the result for this query, executing it once

Returns:

  • (Hash) —

    A GraphQL response, with "data" and/or "errors" keys



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/graphql/query.rb', line 110

def result
  if @executed
    @result
  else
    @executed = true
    instrumenters = @schema.instrumenters[:query]
    begin
      instrumenters.each { |i| i.before_query(self) }
      @result = if !valid?
        all_errors = validation_errors + analysis_errors + context.errors
        if all_errors.any?
          { "errors" => all_errors.map(&:to_h) }
        else
          nil
        end
      else
        Executor.new(self).result
      end
    ensure
      instrumenters.each { |i| i.after_query(self) }
    end
  end
end

#variables ⇒ GraphQL::Query::Variables

Determine the values for variables of this query, using default values if a value isn't provided at runtime.

If some variable is invalid, errors are added to #validation_errors.

Returns:



146
147
148
149
150
151
152
153
154
155
 
# File 'lib/graphql/query.rb', line 146

def variables
  @variables ||= begin
    vars = GraphQL::Query::Variables.new(
      @context,
      @ast_variables,
      @provided_variables,
    )
    vars
  end
end