Class: GraphQL::Schema::InputObject
- Extended by:
- Forwardable, Member::HasArguments, Member::HasArguments::ArgumentObjectLoader, Member::HasValidators, Member::ValidatesInput
- Includes:
- Dig
- Defined in:
- lib/graphql/schema/input_object.rb
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 responding to `to_h` or `to_unsafe_h`."
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
-
#arguments ⇒ GraphQL::Execution::Interpereter::Arguments
readonly
The underlying arguments instance.
-
#context ⇒ GraphQL::Query::Context
readonly
The context for this query.
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
Class Method Summary collapse
- .argument(*args, **kwargs, &block) ⇒ Object
- .authorized?(obj, value, ctx) ⇒ Boolean
- .coerce_input(value, ctx) ⇒ Object
-
.coerce_result(value, ctx) ⇒ Object
It's funny to think of a result of an input object.
- .kind ⇒ Object
- .one_of ⇒ Object
- .one_of? ⇒ Boolean
- .validate_non_null_input(input, ctx, max_errors: nil) ⇒ Object
Instance Method Summary collapse
-
#[](key) ⇒ Object
Lookup a key on this object, it accepts new-style underscored symbols Or old-style camelized identifiers.
-
#initialize(arguments, ruby_kwargs:, context:, defaults_used:) ⇒ InputObject
constructor
A new instance of InputObject.
- #key?(key) ⇒ Boolean
- #prepare ⇒ Object
- #to_h ⇒ Object
- #to_hash ⇒ Object
-
#to_kwargs ⇒ Object
A copy of the Ruby-style hash.
- #unwrap_value(value) ⇒ Object
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
Methods included from Dig
Methods included from Member::BaseDSLMethods
#authorized?, #default_relay, #description, #introspection, #introspection?, #mutation, #name, #visible?
Methods included from Member::BaseDSLMethods::ConfigurationExtension
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
Methods included from Member::HasAstNode
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.
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
# File 'lib/graphql/schema/input_object.rb', line 21 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. self.class.arguments(context).each_value 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.
16 17 18 |
# File 'lib/graphql/schema/input_object.rb', line 16 def arguments @arguments end |
#context ⇒ GraphQL::Query::Context (readonly)
Returns The context for this query.
14 15 16 |
# File 'lib/graphql/schema/input_object.rb', line 14 def context @context end |
Class Method Details
.argument(*args, **kwargs, &block) ⇒ Object
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
# File 'lib/graphql/schema/input_object.rb', line 123 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 class_eval <<-RUBY, __FILE__, __LINE__ def #{method_name} self[#{method_name.inspect}] end RUBY argument_defn end |
.authorized?(obj, value, ctx) ⇒ Boolean
58 59 60 61 62 63 64 65 66 67 68 69 70 |
# File 'lib/graphql/schema/input_object.rb', line 58 def self.(obj, value, ctx) # Authorize each argument (but this doesn't apply if `prepare` is implemented): if value.respond_to?(:key?) arguments(ctx).each do |_name, input_obj_arg| if value.key?(input_obj_arg.keyword) && !input_obj_arg.(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
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 |
# File 'lib/graphql/schema/input_object.rb', line 207 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 input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil) input_obj_instance.prepare 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.
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 |
# File 'lib/graphql/schema/input_object.rb', line 226 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 |
.kind ⇒ Object
143 144 145 |
# File 'lib/graphql/schema/input_object.rb', line 143 def kind GraphQL::TypeKinds::INPUT_OBJECT end |
.one_of ⇒ Object
72 73 74 75 76 77 78 79 |
# File 'lib/graphql/schema/input_object.rb', line 72 def self.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
81 82 83 |
# File 'lib/graphql/schema/input_object.rb', line 81 def self.one_of? directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) } end |
.validate_non_null_input(input, ctx, max_errors: nil) ⇒ Object
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 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 |
# File 'lib/graphql/schema/input_object.rb', line 150 def validate_non_null_input(input, ctx, max_errors: nil) warden = ctx.warden 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 = self.arguments(ctx).reduce({}) do |m, (argument_name, argument)| if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name) m[argument_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 = warden.get_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.
103 104 105 106 107 108 109 110 111 |
# File 'lib/graphql/schema/input_object.rb', line 103 def [](key) if @ruby_style_hash.key?(key) @ruby_style_hash[key] elsif @arguments @arguments[key] else nil end end |
#key?(key) ⇒ Boolean
113 114 115 |
# File 'lib/graphql/schema/input_object.rb', line 113 def key?(key) @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key)) || false end |
#prepare ⇒ Object
47 48 49 50 51 52 53 54 55 56 |
# File 'lib/graphql/schema/input_object.rb', line 47 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
39 40 41 |
# File 'lib/graphql/schema/input_object.rb', line 39 def to_h unwrap_value(@ruby_style_hash) end |
#to_hash ⇒ Object
43 44 45 |
# File 'lib/graphql/schema/input_object.rb', line 43 def to_hash to_h end |
#to_kwargs ⇒ Object
A copy of the Ruby-style hash
118 119 120 |
# File 'lib/graphql/schema/input_object.rb', line 118 def to_kwargs @ruby_style_hash.dup end |
#unwrap_value(value) ⇒ Object
85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
# File 'lib/graphql/schema/input_object.rb', line 85 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 |