Class: GraphQL::Schema::InputObject
- Extended by:
- Forwardable, Member::AcceptsDefinition, Member::HasArguments, Member::HasArguments::ArgumentObjectLoader, 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::GraphQLTypeNames
Member::GraphQLTypeNames::Boolean, Member::GraphQLTypeNames::ID, Member::GraphQLTypeNames::Int
Class Attribute Summary collapse
Instance Attribute Summary collapse
-
#arguments ⇒ GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments
readonly
The underlying arguments instance.
-
#context ⇒ GraphQL::Query::Context
readonly
The context for this query.
Class Method Summary collapse
-
.argument(*args, **kwargs, &block) ⇒ Object
-
.coerce_input(value, ctx) ⇒ Object
-
.coerce_result(value, ctx) ⇒ Object
It’s funny to think of a result of an input object.
-
.kind ⇒ Object
-
.to_graphql ⇒ Object
-
.validate_non_null_input(input, ctx) ⇒ 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 = nil, ruby_kwargs: nil, 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::ValidatesInput
coerce_isolated_input, coerce_isolated_result, valid_input?, valid_isolated_input?, validate_input
Methods included from Member::HasArguments::ArgumentObjectLoader
load_application_object, load_application_object_failed, object_from_id
Methods included from Member::HasArguments
add_argument, argument, argument_class, arguments_statically_coercible?, coerce_arguments, own_arguments
Methods included from Dig
Methods included from Member::HasAstNode
Methods included from Member::HasPath
Methods included from Member::RelayShortcuts
#connection_type, #connection_type_class, #edge_type, #edge_type_class
Methods included from Member::Scoped
Methods included from Member::TypeSystemHelpers
#kind, #list?, #non_null?, #to_list_type, #to_non_null_type, #to_type_signature
Methods included from Member::BaseDSLMethods::ConfigurationExtension
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, #type_class
Constructor Details
#initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:) ⇒ InputObject
Returns a new instance of InputObject.
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
# File 'lib/graphql/schema/input_object.rb', line 13 def initialize(arguments = nil, ruby_kwargs: nil, context:, defaults_used:) @context = context if ruby_kwargs @ruby_style_hash = ruby_kwargs @arguments = arguments else @arguments = self.class.arguments_class.new(arguments, context: context, defaults_used: defaults_used) # Symbolized, underscored hash: @ruby_style_hash = @arguments.to_kwargs end # Apply prepares, not great to have it duplicated here. maybe_lazies = [] self.class.arguments.each_value do |arg_defn| ruby_kwargs_key = arg_defn.keyword if @ruby_style_hash.key?(ruby_kwargs_key) loads = arg_defn.loads # Resolvers do this loading themselves; # With the interpreter, it's done during `coerce_arguments` if loads && !arg_defn.from_resolver? && !context.interpreter? value = @ruby_style_hash[ruby_kwargs_key] loaded_value = if arg_defn.type.list? value.map { |val| load_application_object(arg_defn, loads, val, context) } else load_application_object(arg_defn, loads, value, context) end maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value| @ruby_style_hash[ruby_kwargs_key] = loaded_value end end # 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? || !context.interpreter? @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key]) end end end @maybe_lazies = maybe_lazies end |
Class Attribute Details
.arguments_class ⇒ Class<GraphQL::Arguments>
123 124 125 |
# File 'lib/graphql/schema/input_object.rb', line 123 def arguments_class @arguments_class end |
Instance Attribute Details
#arguments ⇒ GraphQL::Query::Arguments, GraphQL::Execution::Interpereter::Arguments (readonly)
Returns The underlying arguments instance.
59 60 61 |
# File 'lib/graphql/schema/input_object.rb', line 59 def arguments @arguments end |
#context ⇒ GraphQL::Query::Context (readonly)
Returns The context for this query.
56 57 58 |
# File 'lib/graphql/schema/input_object.rb', line 56 def context @context end |
Class Method Details
.argument(*args, **kwargs, &block) ⇒ Object
125 126 127 128 129 130 131 132 |
# File 'lib/graphql/schema/input_object.rb', line 125 def argument(*args, **kwargs, &block) argument_defn = super(*args, **kwargs, &block) # Add a method access method_name = argument_defn.keyword define_method(method_name) do self[method_name] end end |
.coerce_input(value, ctx) ⇒ Object
205 206 207 208 209 210 211 212 213 214 215 216 |
# File 'lib/graphql/schema/input_object.rb', line 205 def coerce_input(value, ctx) if value.nil? return nil end arguments = coerce_arguments(nil, value, ctx) ctx.schema.after_lazy(arguments) do |resolved_arguments| input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil) input_obj_instance.prepare 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.
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 |
# File 'lib/graphql/schema/input_object.rb', line 220 def coerce_result(value, ctx) # Allow the application to provide values as :symbols, and convert them to the strings value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo } result = {} arguments.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
151 152 153 |
# File 'lib/graphql/schema/input_object.rb', line 151 def kind GraphQL::TypeKinds::INPUT_OBJECT end |
.to_graphql ⇒ Object
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 |
# File 'lib/graphql/schema/input_object.rb', line 134 def to_graphql type_defn = GraphQL::InputObjectType.new type_defn.name = graphql_name type_defn.description = description type_defn.[:type_class] = self type_defn.mutation = mutation type_defn.ast_node = ast_node arguments.each do |name, arg| type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition end # Make a reference to a classic-style Arguments class self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn) # But use this InputObject class at runtime type_defn.arguments_class = self type_defn end |
.validate_non_null_input(input, ctx) ⇒ Object
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 |
# File 'lib/graphql/schema/input_object.rb', line 159 def validate_non_null_input(input, ctx) result = GraphQL::Query::InputValidationResult.new warden = ctx.warden if input.is_a?(Array) result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) }) return result end # We're not actually _using_ the coerced result, we're just # using these methods to make sure that the object will # behave like a hash below, when we call `each` on it. begin input.to_h rescue begin # Handle ActionController::Parameters: input.to_unsafe_h rescue # We're not sure it'll act like a hash, so reject it: result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) }) return result end end visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m} # Items in the input that are unexpected input.each do |name, value| if visible_arguments_map[name].nil? result.add_problem("Field is not defined on #{self.graphql_name}", [name]) end end # Items in the input that are expected, but have invalid values visible_arguments_map.map do |name, argument| argument_result = argument.type.validate_input(input[name], ctx) if !argument_result.valid? result.merge_result!(name, argument_result) 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.
102 103 104 105 106 107 108 109 110 |
# File 'lib/graphql/schema/input_object.rb', line 102 def [](key) if @ruby_style_hash.key?(key) @ruby_style_hash[key] elsif @arguments @arguments[key] else nil end end |
#key?(key) ⇒ Boolean
112 113 114 |
# File 'lib/graphql/schema/input_object.rb', line 112 def key?(key) @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key)) || false end |
#prepare ⇒ Object
74 75 76 77 78 79 80 81 82 |
# File 'lib/graphql/schema/input_object.rb', line 74 def prepare if context context.schema.after_any_lazies(@maybe_lazies) do self end else self end end |
#to_h ⇒ Object
64 65 66 67 68 |
# File 'lib/graphql/schema/input_object.rb', line 64 def to_h @ruby_style_hash.inject({}) do |h, (key, value)| h.merge(key => unwrap_value(value)) end end |
#to_hash ⇒ Object
70 71 72 |
# File 'lib/graphql/schema/input_object.rb', line 70 def to_hash to_h end |
#to_kwargs ⇒ Object
A copy of the Ruby-style hash
117 118 119 |
# File 'lib/graphql/schema/input_object.rb', line 117 def to_kwargs @ruby_style_hash.dup end |
#unwrap_value(value) ⇒ Object
84 85 86 87 88 89 90 91 92 93 94 95 96 97 |
# File 'lib/graphql/schema/input_object.rb', line 84 def unwrap_value(value) case value when Array value.map { |item| unwrap_value(item) } when Hash value.inject({}) do |h, (key, value)| h.merge(key => unwrap_value(value)) end when InputObject value.to_h else value end end |