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/literal_input.rb,
lib/graphql/query/serial_execution.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

Classes: Arguments, Context, Executor, InputValidationResult, InvertedMask, LegacyMaskWrap, LiteralInput, MergedMask, OperationNameMissingError, SerialExecution, 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)>) (defaults to: nil) —

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



35
36
37
38
39
40
41
42
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
 
# File 'lib/graphql/query.rb', line 35

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 = MergedMask.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)
  @max_depth = max_depth || schema.max_depth
  @max_complexity = max_complexity || schema.max_complexity
  @query_analyzers = schema.query_analyzers.dup
  if @max_depth
    @query_analyzers << GraphQL::Analysis::MaxQueryDepth.new(@max_depth)
  end
  if @max_complexity
    @query_analyzers << GraphQL::Analysis::MaxQueryComplexity.new(@max_complexity)
  end
  @root_value = root_value
  @operation_name = operation_name
  @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
  @document = document || GraphQL.parse(query_string)
  @document.definitions.each do |part|
    if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
      @fragments[part.name] = part
    elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
      @operations[part.name] = part
    else
      raise GraphQL::ExecutionError, "GraphQL query cannot contain a schema definition"
    end
  end

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

  @arguments_cache = Hash.new { |h, k| h[k] = {} }
  @validation_errors = []
  @analysis_errors = []
  @internal_representation = nil
  @was_validated = false

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

Instance Attribute Details

#context ⇒ Object (readonly)

Returns the value of attribute context.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def context
  @context
end

#document ⇒ Object (readonly)

Returns the value of attribute document.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def document
  @document
end

#fragments ⇒ Object (readonly)

Returns the value of attribute fragments.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def fragments
  @fragments
end

#max_depth ⇒ Object (readonly)

Returns the value of attribute max_depth.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def max_depth
  @max_depth
end

#operations ⇒ Object (readonly)

Returns the value of attribute operations.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def operations
  @operations
end

#provided_variables ⇒ Object (readonly)

Returns the value of attribute provided_variables.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def provided_variables
  @provided_variables
end

#query_string ⇒ Object (readonly)

Returns the value of attribute query_string.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def query_string
  @query_string
end

#root_value ⇒ Object (readonly)

Returns the value of attribute root_value.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def root_value
  @root_value
end

#schema ⇒ Object (readonly)

Returns the value of attribute schema.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def schema
  @schema
end

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

Returns:



127
128
129
 
# File 'lib/graphql/query.rb', line 127

def selected_operation
  @selected_operation
end

#warden ⇒ Object (readonly)

Returns the value of attribute warden.



23
24
25
 
# File 'lib/graphql/query.rb', line 23

def warden
  @warden
end

Instance Method Details

#analysis_errors ⇒ Array<Hash>

TODO this should probably contain error instances, not hashes

Returns:

  • (Array<Hash>) —

    Errors for this particular query run (eg, exceeds max complexity)



171
172
173
174
 
# File 'lib/graphql/query.rb', line 171

def analysis_errors
  valid?
  @analysis_errors
end

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

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

Returns:



178
179
180
181
182
183
184
185
186
 
# File 'lib/graphql/query.rb', line 178

def arguments_for(irep_node, definition)
  @arguments_cache[irep_node][definition] ||= begin
    GraphQL::Query::LiteralInput.from_arguments(
      irep_node.ast_node.arguments,
      definition.arguments,
      self.variables
    )
  end
end

#internal_representation ⇒ Hash<String, nil => GraphQL::InternalRepresentation::Node] Operation name -

Returns Irep node pairs.

Returns:



149
150
151
152
 
# File 'lib/graphql/query.rb', line 149

def internal_representation
  valid?
  @internal_representation
end

#irep_selection ⇒ Object 



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

def irep_selection
  @selection ||= begin
    irep_root = internal_representation[selected_operation.name]
    GraphQL::InternalRepresentation::Selection.new(query: self, nodes: [irep_root])
  end
end

#mutation? ⇒ Boolean

Returns:

  • (Boolean) 


211
212
213
 
# File 'lib/graphql/query.rb', line 211

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`


207
208
209
 
# File 'lib/graphql/query.rb', line 207

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



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/graphql/query.rb', line 99

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
        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

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


191
192
193
194
195
196
197
198
199
 
# File 'lib/graphql/query.rb', line 191

def valid?
  @was_validated ||= begin
    @was_validated = true
    @valid = document_valid? && query_valid? && variables.errors.none?
    true
  end

  @valid
end

#validation_errors ⇒ Array<Hash>

TODO this should probably contain error instances, not hashes

Returns:

  • (Array<Hash>) —

    Static validation errors for the query string



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

def validation_errors
  valid?
  @validation_errors
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:



135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/graphql/query.rb', line 135

def variables
  @variables ||= begin
    vars = GraphQL::Query::Variables.new(
      @schema,
      @warden,
      @ast_variables,
      @provided_variables,
    )
    @validation_errors.concat(vars.errors)
    vars
  end
end