Class: GraphQL::Schema::InputObject

Inherits:
Member
  • Object
show all
Extended by:
Forwardable, Member::HasArguments, Member::HasArguments::ArgumentObjectLoader, Member::HasValidators, Member::ValidatesInput
Includes:
Dig
Defined in:
lib/graphql/schema/input_object.rb

Defined Under Namespace

Classes: ArgumentsAreRequiredError

Constant Summary collapse

INVALID_OBJECT_MESSAGE =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

"Expected %{object} to be a key-value object."

Constants included from Member::HasArguments

Member::HasArguments::NO_ARGUMENTS

Constants included from EmptyObjects

EmptyObjects::EMPTY_ARRAY, EmptyObjects::EMPTY_HASH

Constants included from Member::GraphQLTypeNames

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

Instance Attribute Summary collapse

Attributes included from Member::BaseDSLMethods

#default_graphql_name, #graphql_name

Attributes included from Member::RelayShortcuts

#connection_type, #connection_type_class, #edge_type, #edge_type_class

Attributes included from Member::HasAstNode

#ast_node

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Member::HasArguments

add_argument, all_argument_definitions, any_arguments?, argument, argument_class, arguments_statically_coercible?, coerce_arguments, get_argument, own_arguments, remove_argument, validate_directive_argument

Methods included from Member::HasArguments::ArgumentObjectLoader

authorize_application_object, load_and_authorize_application_object, load_application_object, load_application_object_failed, object_from_id

Methods included from Member::ValidatesInput

coerce_isolated_input, coerce_isolated_result, valid_input?, valid_isolated_input?, validate_input

Methods included from Member::HasValidators

validates, validators

Methods included from Dig

#dig

Methods included from Member::BaseDSLMethods

#authorized?, #comment, #default_relay, #description, #introspection, #introspection?, #mutation, #name, #visible?

Methods included from Member::BaseDSLMethods::ConfigurationExtension

#inherited

Methods included from Member::TypeSystemHelpers

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

Methods included from Member::Scoped

#inherited, #reauthorize_scoped_objects, #scope_items

Methods included from Member::HasPath

#path

Methods included from Member::HasAstNode

#inherited

Methods included from Member::HasDirectives

add_directive, #directive, #directives, get_directives, #inherited, #remove_directive, remove_directive

Constructor Details

#initialize(arguments, ruby_kwargs:, context:, defaults_used:) ⇒ InputObject

Returns a new instance of InputObject.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/graphql/schema/input_object.rb', line 29

def initialize(arguments, ruby_kwargs:, context:, defaults_used:)
  @context = context
  @ruby_style_hash = ruby_kwargs
  @arguments = arguments
  # Apply prepares, not great to have it duplicated here.
  arg_defns = context ? context.types.arguments(self.class) : self.class.arguments(context).each_value
  arg_defns.each do |arg_defn|
    ruby_kwargs_key = arg_defn.keyword
    if @ruby_style_hash.key?(ruby_kwargs_key)
      # Weirdly, procs are applied during coercion, but not methods.
      # Probably because these methods require a `self`.
      if arg_defn.prepare.is_a?(Symbol) || context.nil?
        prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
        overwrite_argument(ruby_kwargs_key, prepared_value)
      end
    end
  end
end

Instance Attribute Details

#arguments ⇒ GraphQL::Execution::Interpereter::Arguments (readonly)

Returns The underlying arguments instance.

Returns:

  • (GraphQL::Execution::Interpereter::Arguments) —

    The underlying arguments instance



24
25
26
 
# File 'lib/graphql/schema/input_object.rb', line 24

def arguments
  @arguments
end

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

Returns The context for this query.

Returns:



22
23
24
 
# File 'lib/graphql/schema/input_object.rb', line 22

def context
  @context
end

Class Method Details

.argument(*args, **kwargs, &block) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/graphql/schema/input_object.rb', line 142

def argument(*args, **kwargs, &block)
  argument_defn = super(*args, **kwargs, &block)
  if one_of?
    if argument_defn.type.non_null?
      raise ArgumentError, "Argument '#{argument_defn.path}' must be nullable because it is part of a OneOf type, add `required: false`."
    end
    if argument_defn.default_value?
      raise ArgumentError, "Argument '#{argument_defn.path}' cannot have a default value because it is part of a OneOf type, remove `default_value: ...`."
    end
  end
  # Add a method access
  method_name = argument_defn.keyword
  suppress_redefinition_warning do
    class_eval <<-RUBY, __FILE__, __LINE__
      def #{method_name}
        self[#{method_name.inspect}]
      end
      alias_method :#{method_name}, :#{method_name}
    RUBY
  end
  argument_defn
end

.arguments(context = GraphQL::Query::NullContext.instance, require_defined_arguments = true) ⇒ Object 



279
280
281
282
283
284
 
# File 'lib/graphql/schema/input_object.rb', line 279

def arguments(context = GraphQL::Query::NullContext.instance, require_defined_arguments = true)
  if require_defined_arguments && !has_no_arguments? && !any_arguments?
    warn(GraphQL::Schema::InputObject::ArgumentsAreRequiredError.new(self).message + "\n\nThis will raise an error in a future GraphQL-Ruby version.")
  end
  super(context, false)
end

.authorized?(obj, value, ctx) ⇒ Boolean

Returns:



115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/graphql/schema/input_object.rb', line 115

def authorized?(obj, value, ctx)
  # Authorize each argument (but this doesn't apply if `prepare` is implemented):
  if value.respond_to?(:key?)
    ctx.types.arguments(self).each do |input_obj_arg|
      if value.key?(input_obj_arg.keyword) &&
        !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
        return false
      end
    end
  end
  # It didn't early-return false:
  true
end

.coerce_input(value, ctx) ⇒ Object 



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/graphql/schema/input_object.rb', line 229

def coerce_input(value, ctx)
  if value.nil?
    return nil
  end

  arguments = coerce_arguments(nil, value, ctx)

  ctx.query.after_lazy(arguments) do |resolved_arguments|
    if resolved_arguments.is_a?(GraphQL::Error)
      raise resolved_arguments
    else
      self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
    end
  end
end

.coerce_result(value, ctx) ⇒ Object

It's funny to think of a result of an input object. This is used for rendering the default value in introspection responses.



247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/graphql/schema/input_object.rb', line 247

def coerce_result(value, ctx)
  # Allow the application to provide values as :snake_symbols, and convert them to the camelStrings
  value = value.reduce({}) { |memo, (k, v)| memo[Member::BuildType.camelize(k.to_s)] = v; memo }

  result = {}

  arguments(ctx).each do |input_key, input_field_defn|
    input_value = value[input_key]
    if value.key?(input_key)
      result[input_key] = if input_value.nil?
        nil
      else
        input_field_defn.type.coerce_result(input_value, ctx)
      end
    end
  end

  result
end

.has_no_arguments(new_has_no_arguments) ⇒ void

This method returns an undefined value.

Parameters:

  • new_has_no_arguments (Boolean) —

    Call with true to make this InputObject type ignore the requirement to have any defined arguments.



269
270
271
272
 
# File 'lib/graphql/schema/input_object.rb', line 269

def has_no_arguments(new_has_no_arguments)
  @has_no_arguments = new_has_no_arguments
  nil
end

.has_no_arguments? ⇒ Boolean

Returns true if has_no_arguments(true) was configued.

Returns:

  • (Boolean) —

    true if has_no_arguments(true) was configued



275
276
277
 
# File 'lib/graphql/schema/input_object.rb', line 275

def has_no_arguments?
  @has_no_arguments
end

.kind ⇒ Object 



165
166
167
 
# File 'lib/graphql/schema/input_object.rb', line 165

def kind
  GraphQL::TypeKinds::INPUT_OBJECT
end

.one_of ⇒ Object 



129
130
131
132
133
134
135
136
 
# File 'lib/graphql/schema/input_object.rb', line 129

def one_of
  if !one_of?
    if all_argument_definitions.any? { |arg| arg.type.non_null? }
      raise ArgumentError, "`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
    end
    directive(GraphQL::Schema::Directive::OneOf)
  end
end

.one_of? ⇒ Boolean

Returns:



138
139
140
 
# File 'lib/graphql/schema/input_object.rb', line 138

def one_of?
  false # Re-defined when `OneOf` is added
end

.validate_non_null_input(input, ctx, max_errors: nil) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/graphql/schema/input_object.rb', line 172

def validate_non_null_input(input, ctx, max_errors: nil)
  types = ctx.types

  if input.is_a?(Array)
    return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
  end

  if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
    # We're not sure it'll act like a hash, so reject it:
    return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
  end

  # Inject missing required arguments
  missing_required_inputs = ctx.types.arguments(self).reduce({}) do |m, (argument)|
    if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value? && types.argument(self, argument.graphql_name)
      m[argument.graphql_name] = nil
    end

    m
  end

  result = nil
  [input, missing_required_inputs].each do |args_to_validate|
    args_to_validate.each do |argument_name, value|
      argument = types.argument(self, argument_name)
      # Items in the input that are unexpected
      if argument.nil?
        result ||= Query::InputValidationResult.new
        result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
      else
        # Items in the input that are expected, but have invalid values
        argument_result = argument.type.validate_input(value, ctx)
        result ||= Query::InputValidationResult.new
        if !argument_result.valid?
          result.merge_result!(argument_name, argument_result)
        end
      end
    end
  end

  if one_of?
    if input.size == 1
      input.each do |name, value|
        if value.nil?
          result ||= Query::InputValidationResult.new
          result.add_problem("'#{graphql_name}' requires exactly one argument, but '#{name}' was `null`.")
        end
      end
    else
      result ||= Query::InputValidationResult.new
      result.add_problem("'#{graphql_name}' requires exactly one argument, but #{input.size} were provided.")
    end
  end

  result
end

Instance Method Details

#[](key) ⇒ Object

Lookup a key on this object, it accepts new-style underscored symbols Or old-style camelized identifiers.

Parameters:

  • key (Symbol, String) 


95
96
97
98
99
100
101
102
103
 
# File 'lib/graphql/schema/input_object.rb', line 95

def [](key)
  if @ruby_style_hash.key?(key)
    @ruby_style_hash[key]
  elsif @arguments
    @arguments[key]
  else
    nil
  end
end

#deconstruct_keys(keys = nil) ⇒ Object 



56
57
58
59
60
61
62
63
64
 
# File 'lib/graphql/schema/input_object.rb', line 56

def deconstruct_keys(keys = nil)
  if keys.nil?
    @ruby_style_hash
  else
    new_h = {}
    keys.each { |k| @ruby_style_hash.key?(k) && new_h[k] = @ruby_style_hash[k] }
    new_h 
  end
end

#key?(key) ⇒ Boolean

Returns:



105
106
107
 
# File 'lib/graphql/schema/input_object.rb', line 105

def key?(key)
  @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key)) || false
end

#prepare ⇒ Object 



66
67
68
69
70
71
72
73
74
75
 
# File 'lib/graphql/schema/input_object.rb', line 66

def prepare
  if @context
    object = @context[:current_object]
    # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
    Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
    self
  else
    self
  end
end

#to_h ⇒ Object 



48
49
50
 
# File 'lib/graphql/schema/input_object.rb', line 48

def to_h
  unwrap_value(@ruby_style_hash)
end

#to_hash ⇒ Object 



52
53
54
 
# File 'lib/graphql/schema/input_object.rb', line 52

def to_hash
  to_h
end

#to_kwargs ⇒ Object

A copy of the Ruby-style hash



110
111
112
 
# File 'lib/graphql/schema/input_object.rb', line 110

def to_kwargs
  @ruby_style_hash.dup
end

#unwrap_value(value) ⇒ Object 



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

def unwrap_value(value)
  case value
  when Array
    value.map { |item| unwrap_value(item) }
  when Hash
    value.reduce({}) do |h, (key, value)|
      h.merge!(key => unwrap_value(value))
    end
  when InputObject
    value.to_h
  else
    value
  end
end