class GraphQL::Field

@api deprecated

def build_default_resolver 

def build_default_resolver
  GraphQL::Field::Resolve.create_proc(self)
end

def connection?

Returns:
  • (Boolean) - 
def connection?
  @connection
end

def edges?

Returns:
  • (Boolean) - 
def edges?
  !!@edge_class
end

def get_argument(argument_name) 

def get_argument(argument_name)
  arguments[argument_name]
end

def hash_key=(new_hash_key)

Parameters:
  • new_hash_key (Symbol) -- A key to access with `#[key]` to resolve this field. Overrides the existing resolve proc. 
def hash_key=(new_hash_key)
  @hash_key = new_hash_key
  self.resolve = nil # reset resolve proc
end

def initialize 

def initialize
  @complexity = 1
  @arguments = {}
  @resolve_proc = build_default_resolver
  @lazy_resolve_proc = DefaultLazyResolve
  @relay_node_field = false
  @connection = false
  @connection_max_page_size = nil
  @edge_class = nil
  @trace = nil
  @introspection = false
end

def initialize_copy(other) 

def initialize_copy(other)
  ensure_defined
  super
  @arguments = other.arguments.dup
end

def introspection?

Returns:
  • (Boolean) - Is this field a predefined introspection field? 
def introspection?
  @introspection
end

def lazy_resolve(obj, args, ctx)

Returns:
  • (Object) - The result of calling the registered method on `obj`

Parameters:
  • ctx (GraphQL::Query::Context) -- Context for this field
  • args (GraphQL::Query::Arguments) -- Arguments to this field
  • obj (Object) -- The {#resolve}-provided object, registered with {Schema#lazy_resolve} 
def lazy_resolve(obj, args, ctx)
  @lazy_resolve_proc.call(obj, args, ctx)
end

def lazy_resolve=(new_lazy_resolve_proc)

Assign a new resolve proc to this field. Used for {#lazy_resolve} 
def lazy_resolve=(new_lazy_resolve_proc)
  @lazy_resolve_proc = new_lazy_resolve_proc
end

def name=(new_name) 

def name=(new_name)
  old_name = defined?(@name) ? @name : nil
  @name = new_name
  if old_name != new_name && @resolve_proc.is_a?(Field::Resolve::NameResolve)
    # Since the NameResolve would use the old field name,
    # reset resolve proc when the name has changed
    self.resolve = nil
  end
end

def prepare_lazy(obj, args, ctx)

Returns:
  • (GraphQL::Execution::Lazy) - A lazy wrapper around `obj` and its registered method name 
def prepare_lazy(obj, args, ctx)
  GraphQL::Execution::Lazy.new {
    lazy_resolve(obj, args, ctx)
  }
end

def property=(new_property)

Parameters:
  • new_property (Symbol) -- A method to call to resolve this field. Overrides the existing resolve proc. 
def property=(new_property)
  @property = new_property
  self.resolve = nil # reset resolve proc
end

def resolve(object, arguments, context)

Parameters:
  • context (GraphQL::Query::Context) --
  • arguments (Hash) -- Arguments declared in the query
  • object (Object) -- The object this field belongs to

Other tags:
    Example: resolving a field value - 
def resolve(object, arguments, context)
  resolve_proc.call(object, arguments, context)
end

def resolve=(new_resolve_proc)

Parameters:
  • new_resolve_proc (<#call(obj, args, ctx)>, nil) -- 
def resolve=(new_resolve_proc)
  @resolve_proc = new_resolve_proc || build_default_resolver
end

def to_s 

def to_s
  "<Field name:#{name || "not-named"} desc:#{description} resolve:#{resolve_proc}>"
end

def type

Get the return type for this field. 
def type
  @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
end

def type=(new_return_type) 

def type=(new_return_type)
  @clean_type = nil
  @dirty_type = new_return_type
end

def type_class 

def type_class
  metadata[:type_class]
end