class GraphQL::Execution::Interpreter

Public Class Methods

begin_multiplex(multiplex) click to toggle source
# File lib/graphql/execution/interpreter.rb, line 14
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 20
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 30
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 35
def self.finish_query(query, _multiplex)
  {
    "data" => query.context.namespace(:interpreter)[:runtime].final_result
  }
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 43
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
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 59
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