module GraphQL::Types::Relay::ConnectionBehaviors::ClassMethods

def accessible?(ctx) 

def accessible?(ctx)
  node_type.accessible?(ctx)
end

def authorized?(obj, ctx) 

def authorized?(obj, ctx)
  true # Let nodes be filtered out
end

def define_nodes_field(nullable, field_options: nil) 

def define_nodes_field(nullable, field_options: nil)
  base_field_options = {
    name: :nodes,
    type: [@node_type, null: nullable],
    null: nullable,
    description: "A list of nodes.",
    connection: false,
  }
  if field_options
    base_field_options.merge!(field_options)
  end
  field(**base_field_options)
end

def edge_nullable(new_value = nil)

Use `edge_nullable(false)` in your base class to make non-null `edge` fields.
Set the default `edge_nullable` for this class and its child classes. (Defaults to `true`.) 
def edge_nullable(new_value = nil)
  if new_value.nil?
    defined?(@edge_nullable) ? @edge_nullable : superclass.edge_nullable
  else
    @edge_nullable = new_value
  end
end

def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)

Parameters:
  • field_options (Hash) -- Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations 
def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
  # Set this connection's graphql name
  node_type_name = node_type.graphql_name
  @node_type = node_type
  @edge_type = edge_type_class
  @edge_class = edge_class
  base_field_options = {
    name: :edges,
    type: [edge_type_class, null: edge_nullable],
    null: edges_nullable,
    description: "A list of edges.",
    connection: false,
  }
  if field_options
    base_field_options.merge!(field_options)
  end
  field(**base_field_options)
  define_nodes_field(node_nullable, field_options: field_options) if nodes_field
  description("The connection type for #{node_type_name}.")
end

def edges_nullable(new_value = nil)

Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
Set the default `edges_nullable` for this class and its child classes. (Defaults to `true`.) 
def edges_nullable(new_value = nil)
  if new_value.nil?
    defined?(@edges_nullable) ? @edges_nullable : superclass.edges_nullable
  else
    @edges_nullable = new_value
  end
end

def has_nodes_field(new_value = nil)

Use `nodes_field(false)` in your base class to prevent adding of a nodes field.
Set the default `nodes_field` for this class and its child classes. (Defaults to `true`.) 
def has_nodes_field(new_value = nil)
  if new_value.nil?
    defined?(@nodes_field) ? @nodes_field : superclass.has_nodes_field
  else
    @nodes_field = new_value
  end
end

def node_nullable(new_value = nil)

Use `node_nullable(false)` in your base class to make non-null `node` and `nodes` fields.
Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.) 
def node_nullable(new_value = nil)
  if new_value.nil?
    defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
  else
    @node_nullable = new_value
  end
end

def nodes_field(node_nullable: self.node_nullable, field_options: nil)

Add the shortcut `nodes` field to this connection and its subclasses 
def nodes_field(node_nullable: self.node_nullable, field_options: nil)
  define_nodes_field(node_nullable, field_options: field_options)
end

def scope_items(items, context)

Filter this list according to the way its node type would scope them 
def scope_items(items, context)
  node_type.scope_items(items, context)
end

def visible?(ctx) 

def visible?(ctx)
  # if this is an abstract base class, there may be no `node_type`
  node_type ? node_type.visible?(ctx) : super
end