Class: GraphQL::Query

Inherits:
Object
  • Object
show all
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/execution_context.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, LiteralInput, 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) ⇒ 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

  • validate (Boolean) (defaults to: true) —

    if true, ‘query_string` will be validated with StaticValidation::Validator

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



32
33
34
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
 
# File 'lib/graphql/query.rb', line 32

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)
  fail ArgumentError, "a query string or document is required" unless query_string || document

  @schema = schema
  @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
  @context = Context.new(query: self, values: context)
  @root_value = root_value
  @validate = validate
  @operation_name = operation_name
  @fragments = {}
  @operations = {}
  @provided_variables = variables
  @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

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

Instance Attribute Details

#context ⇒ Object (readonly)

Returns the value of attribute context.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def context
  @context
end

#document ⇒ Object (readonly)

Returns the value of attribute document.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def document
  @document
end

#fragments ⇒ Object (readonly)

Returns the value of attribute fragments.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def fragments
  @fragments
end

#max_depth ⇒ Object (readonly)

Returns the value of attribute max_depth.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def max_depth
  @max_depth
end

#operations ⇒ Object (readonly)

Returns the value of attribute operations.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def operations
  @operations
end

#query_string ⇒ Object (readonly)

Returns the value of attribute query_string.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def query_string
  @query_string
end

#root_value ⇒ Object (readonly)

Returns the value of attribute root_value.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def root_value
  @root_value
end

#schema ⇒ Object (readonly)

Returns the value of attribute schema.



20
21
22
 
# File 'lib/graphql/query.rb', line 20

def schema
  @schema
end

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

Returns:



91
92
93
 
# File 'lib/graphql/query.rb', line 91

def selected_operation
  @selected_operation
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)



122
123
124
125
 
# File 'lib/graphql/query.rb', line 122

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:



129
130
131
132
133
134
135
136
137
 
# File 'lib/graphql/query.rb', line 129

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:



107
108
109
110
 
# File 'lib/graphql/query.rb', line 107

def internal_representation
  valid?
  @internal_representation
end

#result ⇒ Object

Get the result for this query, executing it once



72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/graphql/query.rb', line 72

def result
  @result ||= begin
    if !valid?
      all_errors = validation_errors + analysis_errors
      if all_errors.any?
        { "errors" => all_errors }
      else
        nil
      end
    else
      Executor.new(self).result
    end
  end
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


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

def valid?
  if !@was_validated
    @was_validated = true
    @valid = if @validate
      document_valid? && query_possible? && query_valid?
    else
      true
    end
  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



114
115
116
117
 
# File 'lib/graphql/query.rb', line 114

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.

Raises if a non-null variable isn’t provided at runtime.

Returns:



98
99
100
101
102
103
104
 
# File 'lib/graphql/query.rb', line 98

def variables
  @variables ||= GraphQL::Query::Variables.new(
    schema,
    selected_operation.variables,
    @provided_variables
  )
end