class GraphQL::Execution::Interpreter

Public Class Methods

begin_multiplex(multiplex) click to toggle source
# File lib/graphql/execution/interpreter.rb, line 36
def self.begin_multiplex(multiplex)
  # Since this is basically the batching context,
  # share it for a whole multiplex
  multiplex.context[:interpreter_instance] ||= self.new
end
begin_query(query, multiplex) click to toggle source
# File lib/graphql/execution/interpreter.rb, line 42
def self.begin_query(query, multiplex)
  # The batching context is shared by the multiplex,
  # so fetch it out and use that instance.
  interpreter =
    query.context.namespace(:interpreter)[:interpreter_instance] =
    multiplex.context[:interpreter_instance]
  interpreter.evaluate(query)
  query
end
finish_multiplex(_results, multiplex) click to toggle source
# File lib/graphql/execution/interpreter.rb, line 52
def self.finish_multiplex(_results, multiplex)
  interpreter = multiplex.context[:interpreter_instance]
  interpreter.sync_lazies(multiplex: multiplex)
end
finish_query(query, _multiplex) click to toggle source
# File lib/graphql/execution/interpreter.rb, line 57
def self.finish_query(query, _multiplex)
  {
    "data" => query.context.namespace(:interpreter)[:runtime].final_result
  }
end
new() click to toggle source
# File lib/graphql/execution/interpreter.rb, line 14
def initialize
end
use(schema_class) click to toggle source
# File lib/graphql/execution/interpreter.rb, line 24
def self.use(schema_class)
  if schema_class.interpreter?
    definition_line = caller(2, 1).first
    GraphQL::Deprecation.warn("GraphQL::Execution::Interpreter is now the default; remove `use GraphQL::Execution::Interpreter` from the schema definition (#{definition_line})")
  else
    schema_class.query_execution_strategy(self)
    schema_class.mutation_execution_strategy(self)
    schema_class.subscription_execution_strategy(self)
    schema_class.add_subscription_extension_if_necessary
  end
end

Public Instance Methods

evaluate(query) click to toggle source

Run the eager part of `query` @return {Interpreter::Runtime}

# File lib/graphql/execution/interpreter.rb, line 65
def evaluate(query)
  # Although queries in a multiplex _share_ an Interpreter instance,
  # they also have another item of state, which is private to that query
  # in particular, assign it here:
  runtime = Runtime.new(query: query)
  query.context.namespace(:interpreter)[:runtime] = runtime

  query.trace("execute_query", {query: query}) do
    runtime.run_eager
  end

  runtime
end
execute(_operation, _root_type, query) click to toggle source

Support `Executor` :S

# File lib/graphql/execution/interpreter.rb, line 18
def execute(_operation, _root_type, query)
  runtime = evaluate(query)
  sync_lazies(query: query)
  runtime.final_result
end
sync_lazies(query: nil, multiplex: nil) click to toggle source

Run the lazy part of `query` or `multiplex`. @return [void]

# File lib/graphql/execution/interpreter.rb, line 81
def sync_lazies(query: nil, multiplex: nil)
  tracer = query || multiplex
  if query.nil? && multiplex.queries.length == 1
    query = multiplex.queries[0]
  end
  queries = multiplex ? multiplex.queries : [query]
  final_values = queries.map do |query|
    runtime = query.context.namespace(:interpreter)[:runtime]
    # it might not be present if the query has an error
    runtime ? runtime.final_result : nil
  end
  final_values.compact!
  tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
    Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
  end
  queries.each do |query|
    runtime = query.context.namespace(:interpreter)[:runtime]
    if runtime
      runtime.delete_interpreter_context(:current_path)
      runtime.delete_interpreter_context(:current_field)
      runtime.delete_interpreter_context(:current_object)
      runtime.delete_interpreter_context(:current_arguments)
    end
  end
  nil
end