Class: GraphQL::Schema::Object

Inherits:
Member
  • Object
show all
Extended by:
Member::AcceptsDefinition, Member::HasFields
Defined in:
lib/graphql/schema/object.rb

Constant Summary

Constants included from Member::HasFields

Member::HasFields::CONFLICT_FIELD_NAMES, Member::HasFields::GRAPHQL_RUBY_KEYWORDS, Member::HasFields::RUBY_KEYWORDS

Constants included from Member::GraphQLTypeNames

Member::GraphQLTypeNames::Boolean, Member::GraphQLTypeNames::ID, Member::GraphQLTypeNames::Int

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Member::HasFields

add_field, field, field_class, fields, get_field, global_id_field, own_fields

Methods included from Member::HasPath

#path

Methods included from Member::RelayShortcuts

#connection_type, #connection_type_class, #edge_type, #edge_type_class

Methods included from Member::Scoped

#scope_items

Methods included from Member::TypeSystemHelpers

#kind, #list?, #non_null?, #to_list_type, #to_non_null_type, #to_type_signature

Methods included from Member::BaseDSLMethods

#accessible?, #authorized?, #default_graphql_name, #description, #graphql_name, #introspection, #introspection?, #mutation, #name, #overridden_graphql_name, #to_graphql, #visible?

Methods included from Relay::TypeExtensions

#connection_type, #define_connection, #define_edge, #edge_type

Methods included from Member::CachedGraphQLDefinition

#graphql_definition, #initialize_copy

Constructor Details

#initialize(object, context) ⇒ Object

Returns a new instance of Object



70
71
72
73
 
# File 'lib/graphql/schema/object.rb', line 70

def initialize(object, context)
  @object = object
  @context = context
end

Instance Attribute Details

#context ⇒ GraphQL::Query::Context (readonly)

Returns the context instance for this query

Returns:



13
14
15
 
# File 'lib/graphql/schema/object.rb', line 13

def context
  @context
end

#object ⇒ Object (readonly)

Returns the application object this type is wrapping

Returns:

  • (Object) —

    the application object this type is wrapping



10
11
12
 
# File 'lib/graphql/schema/object.rb', line 10

def object
  @object
end

Class Method Details

.authorized_new(object, context) ⇒ GraphQL::Schema::Object, GraphQL::Execution::Lazy

Make a new instance of this type if the auth check passes, otherwise, raise an error.

Probably only the framework should call this method.

This might return a Execution::Lazy if the user-provided .authorized? hook returns some lazy value (like a Promise).

The reason that the auth check is in this wrapper method instead of new is because of how it might return a Promise. It would be weird if .new returned a promise; It would be a headache to try to maintain Promise-y state inside a GraphQL::Schema::Object instance. So, hopefully this wrapper method will do the job.

Parameters:

Returns:

Raises:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/graphql/schema/object.rb', line 37

def authorized_new(object, context)
  auth_val = context.query.with_error_handling do
    begin
      authorized?(object, context)
    rescue GraphQL::UnauthorizedError => err
      context.schema.unauthorized_object(err)
    end
  end

  context.schema.after_lazy(auth_val) do |is_authorized|
    if is_authorized
      self.new(object, context)
    else
      # It failed the authorization check, so go to the schema's authorized object hook
      err = GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
      # If a new value was returned, wrap that instead of the original value
      begin
        new_obj = context.schema.unauthorized_object(err)
        if new_obj
          self.new(new_obj, context)
        else
          nil
        end
      # rescue GraphQL::ExecutionError => err
      #   err
      end
    end
  end
# rescue GraphQL::ExecutionError => err
#   err
end

.fields ⇒ Object

Include legacy-style interfaces, too



101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/graphql/schema/object.rb', line 101

def fields
  all_fields = super
  interfaces.each do |int|
    if int.is_a?(GraphQL::InterfaceType)
      int_f = {}
      int.fields.each do |name, legacy_field|
        int_f[name] = field_class.from_options(name, field: legacy_field)
      end
      all_fields = int_f.merge(all_fields)
    end
  end
  all_fields
end

.implements(*new_interfaces) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/graphql/schema/object.rb', line 76

def implements(*new_interfaces)
  new_interfaces.each do |int|
    if int.is_a?(Module)
      unless int.include?(GraphQL::Schema::Interface)
        raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
      end

      # Include the methods here,
      # `.fields` will use the inheritance chain
      # to find inherited fields
      include(int)
    end
  end
  own_interfaces.concat(new_interfaces)
end

.interfaces ⇒ Object 



92
93
94
 
# File 'lib/graphql/schema/object.rb', line 92

def interfaces
  own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
end

.kind ⇒ Object 



133
134
135
 
# File 'lib/graphql/schema/object.rb', line 133

def kind
  GraphQL::TypeKinds::OBJECT
end

.own_interfaces ⇒ Object 



96
97
98
 
# File 'lib/graphql/schema/object.rb', line 96

def own_interfaces
  @own_interfaces ||= []
end

.to_graphql ⇒ GraphQL::ObjectType

Returns:



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/graphql/schema/object.rb', line 116

def to_graphql
  obj_type = GraphQL::ObjectType.new
  obj_type.name = graphql_name
  obj_type.description = description
  obj_type.interfaces = interfaces
  obj_type.introspection = introspection
  obj_type.mutation = mutation
  fields.each do |field_name, field_inst|
    field_defn = field_inst.to_graphql
    obj_type.fields[field_defn.name] = field_defn
  end

  obj_type.metadata[:type_class] = self

  obj_type
end