class GraphQL::Execution::Lazy

This wraps a value which is available, but not yet calculated, like a promise or future.

Calling ‘#value` will trigger calculation & return the “lazy” value.

This is an itty-bitty promise-like object, with key differences:

@api private

Constants

NullResult

This can be used for fields which _had no_ lazy results @api private

Attributes

field[R]
path[R]

Public Class Methods

all(lazies) click to toggle source

@param lazies [Array<Object>] Maybe-lazy objects @return [Lazy] A lazy which will sync all of ‘lazies`

# File lib/graphql/execution/lazy.rb, line 63
def self.all(lazies)
  self.new {
    lazies.map { |l| l.is_a?(Lazy) ? l.value : l }
  }
end
new(path: nil, field: nil, &get_value_func) click to toggle source

Create a {Lazy} which will get its inner value by calling the block @param path [Array<String, Integer>] @param field [GraphQL::Schema::Field] @param get_value_func [Proc] a block to get the inner value (later)

# File lib/graphql/execution/lazy.rb, line 21
def initialize(path: nil, field: nil, &get_value_func)
  @get_value_func = get_value_func
  @resolved = false
  @path = path
  @field = field
end

Public Instance Methods

then() { |value| ... } click to toggle source

@return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in ‘block`

# File lib/graphql/execution/lazy.rb, line 55
def then
  self.class.new {
    yield(value)
  }
end
value() click to toggle source

@return [Object] The wrapped value, calling the lazy block if necessary

# File lib/graphql/execution/lazy.rb, line 29
def value
  if !@resolved
    @resolved = true
    @value = begin
      v = @get_value_func.call
      if v.is_a?(Lazy)
        v = v.value
      end
      v
    rescue GraphQL::ExecutionError => err
      err
    end
  end

  # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
  # (fewer clauses in a hot `case` block), but now it requires special handling here.
  # I think it's still worth it for the performance win, but if the number of special
  # cases grows, then maybe it's worth rethinking somehow.
  if @value.is_a?(StandardError) && @value != GraphQL::Execution::SKIP
    raise @value
  else
    @value
  end
end