Class: GraphQL::Schema::Field
- Inherits:
-
Object
- Object
- GraphQL::Schema::Field
- Extended by:
- FindInheritedValue
- Includes:
- EmptyObjects, Member::HasArguments, Member::HasArguments::FieldConfigured, Member::HasAstNode, Member::HasDeprecationReason, Member::HasDirectives, Member::HasPath, Member::HasValidators
- Defined in:
- lib/graphql/schema/field.rb,
lib/graphql/schema/field/scope_extension.rb,
lib/graphql/schema/field/connection_extension.rb
Defined Under Namespace
Classes: ConnectionExtension, ExtendedState, FieldImplementationFailed, MissingReturnTypeError, ScopeExtension
Constant Summary
Constants included from EmptyObjects
EmptyObjects::EMPTY_ARRAY, EmptyObjects::EMPTY_HASH
Constants included from Member::HasArguments
Member::HasArguments::NO_ARGUMENTS
Instance Attribute Summary collapse
- #description(text = nil) ⇒ String
-
#dig_keys ⇒ Object
readonly
Returns the value of attribute dig_keys.
-
#dynamic_introspection ⇒ Object
Returns the value of attribute dynamic_introspection.
-
#hash_key ⇒ Object
readonly
Returns the value of attribute hash_key.
-
#method_str ⇒ String
readonly
Method or hash key on the underlying object to look up.
-
#method_sym ⇒ Symbol
readonly
Method or hash key on the underlying object to look up.
-
#name ⇒ String
(also: #graphql_name)
readonly
The GraphQL name for this field, camelized unless
camelize: false
is provided. -
#original_name ⇒ Symbol
readonly
The original name of the field, passed in by the user.
-
#owner ⇒ Class
The thing this field was defined on (type, mutation, resolver).
-
#relay_node_field ⇒ Object
readonly
Boolean.
-
#relay_nodes_field ⇒ Object
readonly
Boolean.
- #subscription_scope ⇒ String?
-
#trace ⇒ Boolean
readonly
Apply tracing to this field? (Default: skip scalars, this is the override value).
- #type ⇒ Object
Attributes included from Member::HasDeprecationReason
Attributes included from Member::HasAstNode
Class Method Summary collapse
-
.connection_extension(new_extension_class = nil) ⇒ Class
This extension is applied to fields when #connection? is true.
-
.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil, **kwargs, &block) ⇒ GraphQL::Schema:Field
Create a field instance from a list of arguments, keyword arguments, and a block.
Instance Method Summary collapse
- #authorized?(object, args, context) ⇒ Boolean
-
#broadcastable? ⇒ Boolean?
If true, subscription updates with this field can be shared between viewers.
- #calculate_complexity(query:, nodes:, child_complexity:) ⇒ Object
- #complexity(new_complexity = nil) ⇒ Object
-
#connection? ⇒ Boolean
Can be set with
connection: true|false
or inferred from a type name ending in*Connection
. -
#default_page_size ⇒ Integer?
Applied to connections if #has_default_page_size?.
-
#extension(extension_class, options = nil) ⇒ void
Add
extension
to this field, initialized withoptions
if provided. -
#extensions(new_extensions = nil) ⇒ Array<GraphQL::Schema::FieldExtension>
Read extension instances from this field, or add new classes/options to be initialized on this field.
-
#extras(new_extras = nil) ⇒ Array<Symbol>
Read extras (as symbols) from this field, or add new extras to be opted into by this field's resolver.
- #fetch_extra(extra_name, ctx) ⇒ Object
-
#has_default_page_size? ⇒ Boolean
True if this field's #default_page_size should override the schema default.
-
#has_max_page_size? ⇒ Boolean
True if this field's #max_page_size should override the schema default.
-
#initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block) ⇒ Field
constructor
A new instance of Field.
- #inspect ⇒ Object
-
#introspection? ⇒ Boolean
Is this field a predefined introspection field?.
-
#max_page_size ⇒ Integer?
Applied to connections if #has_max_page_size?.
-
#method_conflict_warning? ⇒ Boolean
Should we warn if this field's name conflicts with a built-in method?.
-
#owner_type ⇒ Class
The GraphQL type this field belongs to.
-
#resolve(object, args, query_ctx) ⇒ Object
This method is called by the interpreter for each field.
-
#resolver ⇒ Class?
(also: #mutation)
The Resolver this field was derived from, if there is one.
-
#resolver_method ⇒ Symbol
The method on the type to look up.
-
#scoped? ⇒ Boolean
If true, the return type's
.scope_items
method will be applied to this field's return value. - #visible?(context) ⇒ Boolean
Methods included from Member::HasDirectives
add_directive, #directive, #directives, get_directives, #inherited, #remove_directive, remove_directive
Methods included from Member::HasValidators
Methods included from Member::HasPath
Methods included from Member::HasAstNode
Methods included from Member::HasArguments::FieldConfigured
#all_argument_definitions, #any_arguments?, #arguments
Methods included from Member::HasArguments
#add_argument, #all_argument_definitions, #any_arguments?, #argument, #argument_class, #arguments, #arguments_statically_coercible?, #coerce_arguments, #get_argument, #own_arguments, #remove_argument, #validate_directive_argument
Constructor Details
#initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block) ⇒ Field
Returns a new instance of Field.
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 |
# File 'lib/graphql/schema/field.rb', line 222 def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block) if name.nil? raise ArgumentError, "missing first `name` argument or keyword `name:`" end if !(resolver_class) if type.nil? raise ArgumentError, "missing second `type` argument or keyword `type:`" end end @original_name = name name_s = -name.to_s @underscored_name = -Member::BuildType.underscore(name_s) @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s) @description = description @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary self.deprecation_reason = deprecation_reason if method && hash_key && dig raise ArgumentError, "Provide `method:`, `hash_key:` _or_ `dig:`, not multiple. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}, dig: #{dig.inspect}`)" end if resolver_method if method raise ArgumentError, "Provide `method:` _or_ `resolver_method:`, not both. (called with: `method: #{method.inspect}, resolver_method: #{resolver_method.inspect}`)" end if hash_key || dig raise ArgumentError, "Provide `hash_key:`, `dig:`, _or_ `resolver_method:`, not multiple. (called with: `hash_key: #{hash_key.inspect}, dig: #{dig.inspect}, resolver_method: #{resolver_method.inspect}`)" end end method_name = method || hash_key || name_s @dig_keys = dig if hash_key @hash_key = hash_key @hash_key_str = hash_key.to_s else @hash_key = NOT_CONFIGURED @hash_key_str = NOT_CONFIGURED end @method_str = -method_name.to_s @method_sym = method_name.to_sym @resolver_method = (resolver_method || name_s).to_sym @complexity = complexity @dynamic_introspection = dynamic_introspection @return_type_expr = type @return_type_null = if !null.nil? null elsif resolver_class nil else true end @connection = connection @max_page_size = max_page_size @default_page_size = default_page_size @introspection = introspection @extras = extras @broadcastable = broadcastable @resolver_class = resolver_class @scope = scope @trace = trace @relay_node_field = relay_node_field @relay_nodes_field = relay_nodes_field @ast_node = ast_node @method_conflict_warning = method_conflict_warning @fallback_value = fallback_value arguments.each do |name, arg| case arg when Hash argument(name: name, **arg) when GraphQL::Schema::Argument add_argument(arg) when Array arg.each { |a| add_argument(a) } else raise ArgumentError, "Unexpected argument config (#{arg.class}): #{arg.inspect}" end end @owner = owner @subscription_scope = subscription_scope @extensions = EMPTY_ARRAY @call_after_define = false # This should run before connection extension, # but should it run after the definition block? if scoped? self.extension(ScopeExtension) end # The problem with putting this after the definition_block # is that it would override arguments if connection? && connection_extension self.extension(connection_extension) end # Do this last so we have as much context as possible when initializing them: if extensions.any? self.extensions(extensions) end if resolver_class && resolver_class.extensions.any? self.extensions(resolver_class.extensions) end if directives.any? directives.each do |(dir_class, )| self.directive(dir_class, **) end end if !validates.empty? self.validates(validates) end if block_given? if definition_block.arity == 1 yield self else instance_eval(&definition_block) end end self.extensions.each(&:after_define_apply) @call_after_define = true end |
Instance Attribute Details
#description(text = nil) ⇒ String
372 373 374 375 376 377 378 379 380 381 382 |
# File 'lib/graphql/schema/field.rb', line 372 def description(text = nil) if text @description = text elsif !NOT_CONFIGURED.equal?(@description) @description elsif @resolver_class @resolver_class.description else nil end end |
#dig_keys ⇒ Object (readonly)
Returns the value of attribute dig_keys.
33 34 35 |
# File 'lib/graphql/schema/field.rb', line 33 def dig_keys @dig_keys end |
#dynamic_introspection ⇒ Object
Returns the value of attribute dynamic_introspection.
355 356 357 |
# File 'lib/graphql/schema/field.rb', line 355 def dynamic_introspection @dynamic_introspection end |
#hash_key ⇒ Object (readonly)
Returns the value of attribute hash_key.
32 33 34 |
# File 'lib/graphql/schema/field.rb', line 32 def hash_key @hash_key end |
#method_str ⇒ String (readonly)
Returns Method or hash key on the underlying object to look up.
30 31 32 |
# File 'lib/graphql/schema/field.rb', line 30 def method_str @method_str end |
#method_sym ⇒ Symbol (readonly)
Returns Method or hash key on the underlying object to look up.
27 28 29 |
# File 'lib/graphql/schema/field.rb', line 27 def method_sym @method_sym end |
#name ⇒ String (readonly) Also known as: graphql_name
Returns the GraphQL name for this field, camelized unless camelize: false
is provided.
21 22 23 |
# File 'lib/graphql/schema/field.rb', line 21 def name @name end |
#original_name ⇒ Symbol (readonly)
Returns the original name of the field, passed in by the user.
59 60 61 |
# File 'lib/graphql/schema/field.rb', line 59 def original_name @original_name end |
#owner ⇒ Class
Returns The thing this field was defined on (type, mutation, resolver).
45 46 47 |
# File 'lib/graphql/schema/field.rb', line 45 def owner @owner end |
#relay_node_field ⇒ Object (readonly)
Returns Boolean.
184 185 186 |
# File 'lib/graphql/schema/field.rb', line 184 def relay_node_field @relay_node_field end |
#relay_nodes_field ⇒ Object (readonly)
Returns Boolean.
186 187 188 |
# File 'lib/graphql/schema/field.rb', line 186 def relay_nodes_field @relay_nodes_field end |
#subscription_scope ⇒ String?
81 82 83 |
# File 'lib/graphql/schema/field.rb', line 81 def subscription_scope @subscription_scope || (@resolver_class.respond_to?(:subscription_scope) ? @resolver_class.subscription_scope : nil) end |
#trace ⇒ Boolean (readonly)
Returns Apply tracing to this field? (Default: skip scalars, this is the override value).
78 79 80 |
# File 'lib/graphql/schema/field.rb', line 78 def trace @trace end |
#type ⇒ Object
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 |
# File 'lib/graphql/schema/field.rb', line 583 def type if @resolver_class return_type = @return_type_expr || @resolver_class.type_expr if return_type.nil? raise MissingReturnTypeError, "Can't determine the return type for #{self.path} (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)" end nullable = @return_type_null.nil? ? @resolver_class.null : @return_type_null Member::BuildType.parse_type(return_type, null: nullable) else @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null) end rescue GraphQL::Schema::InvalidDocumentError, MissingReturnTypeError => err # Let this propagate up raise err rescue StandardError => err raise MissingReturnTypeError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: (#{err.class}) #{err.}", err.backtrace end |
Class Method Details
.connection_extension(new_extension_class = nil) ⇒ Class
This extension is applied to fields when #connection? is true.
You can override it in your base field definition.
175 176 177 178 179 180 181 |
# File 'lib/graphql/schema/field.rb', line 175 def self.connection_extension(new_extension_class = nil) if new_extension_class @connection_extension = new_extension_class else @connection_extension ||= find_inherited_value(:connection_extension, ConnectionExtension) end end |
.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil, **kwargs, &block) ⇒ GraphQL::Schema:Field
Create a field instance from a list of arguments, keyword arguments, and a block.
This method implements prioritization between the resolver
or mutation
defaults
and the local overrides via other keywords.
It also normalizes positional arguments into keywords for #initialize.
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
# File 'lib/graphql/schema/field.rb', line 97 def self.(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block) if (resolver_class = resolver || mutation || subscription) # Add a reference to that parent class kwargs[:resolver_class] = resolver_class end if name kwargs[:name] = name end if !type.nil? if desc if kwargs[:description] raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{kwargs[:description].inspect})" end kwargs[:description] = desc kwargs[:type] = type elsif (resolver || mutation) && type.is_a?(String) # The return type should be copied from the resolver, and the second positional argument is the description kwargs[:description] = type else kwargs[:type] = type end if type.is_a?(Class) && type < GraphQL::Schema::Mutation raise ArgumentError, "Use `field #{name.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead" end end new(**kwargs, &block) end |
Instance Method Details
#authorized?(object, args, context) ⇒ Boolean
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 |
# File 'lib/graphql/schema/field.rb', line 609 def (object, args, context) if @resolver_class # The resolver _instance_ will check itself during `resolve()` @resolver_class.(object, context) else if args.size > 0 if (arg_values = context[:current_arguments]) # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not. using_arg_values = true arg_values = arg_values.argument_values else arg_values = args using_arg_values = false end args = context.warden.arguments(self) args.each do |arg| arg_key = arg.keyword if arg_values.key?(arg_key) arg_value = arg_values[arg_key] if using_arg_values if arg_value.default_used? # pass -- no auth required for default used next else application_arg_value = arg_value.value if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments) application_arg_value.keyword_arguments end end else application_arg_value = arg_value end if !arg.(object, application_arg_value, context) return false end end end end true end end |
#broadcastable? ⇒ Boolean?
If true, subscription updates with this field can be shared between viewers
360 361 362 363 364 365 366 367 368 |
# File 'lib/graphql/schema/field.rb', line 360 def broadcastable? if !NOT_CONFIGURED.equal?(@broadcastable) @broadcastable elsif @resolver_class @resolver_class.broadcastable? else nil end end |
#calculate_complexity(query:, nodes:, child_complexity:) ⇒ Object
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 |
# File 'lib/graphql/schema/field.rb', line 459 def calculate_complexity(query:, nodes:, child_complexity:) if respond_to?(:complexity_for) lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner) complexity_for(child_complexity: child_complexity, query: query, lookahead: lookahead) elsif connection? arguments = query.arguments_for(nodes.first, self) max_possible_page_size = nil if arguments.respond_to?(:[]) # It might have been an error if arguments[:first] max_possible_page_size = arguments[:first] end if arguments[:last] && (max_possible_page_size.nil? || arguments[:last] > max_possible_page_size) max_possible_page_size = arguments[:last] end end if max_possible_page_size.nil? max_possible_page_size = default_page_size || query.schema.default_page_size || max_page_size || query.schema.default_max_page_size end if max_possible_page_size.nil? raise GraphQL::Error, "Can't calculate complexity for #{path}, no `first:`, `last:`, `default_page_size`, `max_page_size` or `default_max_page_size`" else = 0 lookahead = GraphQL::Execution::Lookahead.new(query: query, field: self, ast_nodes: nodes, owner_type: owner) if (page_info_lookahead = lookahead.selection(:page_info)).selected? += 1 # pageInfo += page_info_lookahead.selections.size # subfields end if lookahead.selects?(:total) || lookahead.selects?(:total_count) || lookahead.selects?(:count) += 1 end nodes_edges_complexity = 0 nodes_edges_complexity += 1 if lookahead.selects?(:edges) nodes_edges_complexity += 1 if lookahead.selects?(:nodes) # Possible bug: selections on `edges` and `nodes` are _both_ multiplied here. Should they be? items_complexity = child_complexity - - nodes_edges_complexity # Add 1 for _this_ field 1 + (max_possible_page_size * items_complexity) + + nodes_edges_complexity end else defined_complexity = complexity case defined_complexity when Proc arguments = query.arguments_for(nodes.first, self) if arguments.is_a?(GraphQL::ExecutionError) return child_complexity elsif arguments.respond_to?(:keyword_arguments) arguments = arguments.keyword_arguments end defined_complexity.call(query.context, arguments, child_complexity) when Numeric defined_complexity + child_complexity else raise("Invalid complexity: #{defined_complexity.inspect} on #{path} (#{inspect})") end end end |
#complexity(new_complexity = nil) ⇒ Object
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 |
# File 'lib/graphql/schema/field.rb', line 524 def complexity(new_complexity = nil) case new_complexity when Proc if new_complexity.parameters.size != 3 fail( "A complexity proc should always accept 3 parameters: ctx, args, child_complexity. "\ "E.g.: complexity ->(ctx, args, child_complexity) { child_complexity * args[:limit] }" ) else @complexity = new_complexity end when Numeric @complexity = new_complexity when nil if @resolver_class @complexity || @resolver_class.complexity || 1 else @complexity || 1 end else raise("Invalid complexity: #{new_complexity.inspect} on #{@name}") end end |
#connection? ⇒ Boolean
Can be set with connection: true|false
or inferred from a type name ending in *Connection
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 |
# File 'lib/graphql/schema/field.rb', line 130 def connection? if @connection.nil? # Provide default based on type name return_type_name = if @return_type_expr Member::BuildType.to_type_name(@return_type_expr) elsif @resolver_class && @resolver_class.type Member::BuildType.to_type_name(@resolver_class.type) else # As a last ditch, try to force loading the return type: type.unwrap.name end @connection = return_type_name.end_with?("Connection") && return_type_name != "Connection" else @connection end end |
#default_page_size ⇒ Integer?
Returns Applied to connections if #has_default_page_size?.
570 571 572 573 574 575 576 577 578 |
# File 'lib/graphql/schema/field.rb', line 570 def default_page_size if !NOT_CONFIGURED.equal?(@default_page_size) @default_page_size elsif @resolver_class && @resolver_class.has_default_page_size? @resolver_class.default_page_size else nil end end |
#extension(extension_class, options = nil) ⇒ void
This method returns an undefined value.
Add extension
to this field, initialized with options
if provided.
424 425 426 427 428 429 430 431 432 433 434 |
# File 'lib/graphql/schema/field.rb', line 424 def extension(extension_class, = nil) extension_inst = extension_class.new(field: self, options: ) if @extensions.frozen? @extensions = @extensions.dup end if @call_after_define extension_inst.after_define_apply end @extensions << extension_inst nil end |
#extensions(new_extensions = nil) ⇒ Array<GraphQL::Schema::FieldExtension>
Read extension instances from this field, or add new classes/options to be initialized on this field. Extensions are executed in the order they are added.
399 400 401 402 403 404 405 406 407 408 409 410 411 |
# File 'lib/graphql/schema/field.rb', line 399 def extensions(new_extensions = nil) if new_extensions new_extensions.each do |extension_config| if extension_config.is_a?(Hash) extension_class, = *extension_config.to_a[0] self.extension(extension_class, ) else self.extension(extension_config) end end end @extensions end |
#extras(new_extras = nil) ⇒ Array<Symbol>
Read extras (as symbols) from this field, or add new extras to be opted into by this field's resolver.
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 |
# File 'lib/graphql/schema/field.rb', line 441 def extras(new_extras = nil) if new_extras.nil? # Read the value field_extras = @extras if @resolver_class && @resolver_class.extras.any? field_extras + @resolver_class.extras else field_extras end else if @extras.frozen? @extras = @extras.dup end # Append to the set of extras on this field @extras.concat(new_extras) end end |
#fetch_extra(extra_name, ctx) ⇒ Object
764 765 766 767 768 769 770 771 772 |
# File 'lib/graphql/schema/field.rb', line 764 def fetch_extra(extra_name, ctx) if extra_name != :path && extra_name != :ast_node && respond_to?(extra_name) self.public_send(extra_name) elsif ctx.respond_to?(extra_name) ctx.public_send(extra_name) else raise GraphQL::RequiredImplementationMissingError, "Unknown field extra for #{self.path}: #{extra_name.inspect}" end end |
#has_default_page_size? ⇒ Boolean
Returns True if this field's #default_page_size should override the schema default.
565 566 567 |
# File 'lib/graphql/schema/field.rb', line 565 def has_default_page_size? !NOT_CONFIGURED.equal?(@default_page_size) || (@resolver_class && @resolver_class.has_default_page_size?) end |
#has_max_page_size? ⇒ Boolean
Returns True if this field's #max_page_size should override the schema default.
549 550 551 |
# File 'lib/graphql/schema/field.rb', line 549 def has_max_page_size? !NOT_CONFIGURED.equal?(@max_page_size) || (@resolver_class && @resolver_class.has_max_page_size?) end |
#inspect ⇒ Object
71 72 73 |
# File 'lib/graphql/schema/field.rb', line 71 def inspect "#<#{self.class} #{path}#{all_argument_definitions.any? ? "(...)" : ""}: #{type.to_type_signature}>" end |
#introspection? ⇒ Boolean
Returns Is this field a predefined introspection field?.
67 68 69 |
# File 'lib/graphql/schema/field.rb', line 67 def introspection? @introspection end |
#max_page_size ⇒ Integer?
Returns Applied to connections if #has_max_page_size?.
554 555 556 557 558 559 560 561 562 |
# File 'lib/graphql/schema/field.rb', line 554 def max_page_size if !NOT_CONFIGURED.equal?(@max_page_size) @max_page_size elsif @resolver_class && @resolver_class.has_max_page_size? @resolver_class.max_page_size else nil end end |
#method_conflict_warning? ⇒ Boolean
Returns Should we warn if this field's name conflicts with a built-in method?.
189 190 191 |
# File 'lib/graphql/schema/field.rb', line 189 def method_conflict_warning? @method_conflict_warning end |
#owner_type ⇒ Class
Returns The GraphQL type this field belongs to. (For fields defined on mutations, it's the payload type).
48 49 50 51 52 53 54 55 56 |
# File 'lib/graphql/schema/field.rb', line 48 def owner_type @owner_type ||= if owner.nil? raise GraphQL::InvariantError, "Field #{original_name.inspect} (graphql name: #{graphql_name.inspect}) has no owner, but all fields should have an owner. How did this happen?!" elsif owner < GraphQL::Schema::Mutation owner.payload_type else owner end end |
#resolve(object, args, query_ctx) ⇒ Object
This method is called by the interpreter for each field. You can extend it in your base field classes.
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 |
# File 'lib/graphql/schema/field.rb', line 658 def resolve(object, args, query_ctx) # Unwrap the GraphQL object to get the application object. application_object = object.object method_receiver = nil method_to_call = nil method_args = nil @own_validators && Schema::Validator.validate!(validators, application_object, query_ctx, args) query_ctx.query.after_lazy(self.(application_object, args, query_ctx)) do || if with_extensions(object, args, query_ctx) do |obj, ruby_kwargs| method_args = ruby_kwargs if @resolver_class if obj.is_a?(GraphQL::Schema::Object) obj = obj.object end obj = @resolver_class.new(object: obj, context: query_ctx, field: self) end inner_object = obj.object if !NOT_CONFIGURED.equal?(@hash_key) hash_value = if inner_object.is_a?(Hash) inner_object.key?(@hash_key) ? inner_object[@hash_key] : inner_object[@hash_key_str] elsif inner_object.respond_to?(:[]) inner_object[@hash_key] else nil end if hash_value == false hash_value else hash_value || (@fallback_value != NOT_CONFIGURED ? @fallback_value : nil) end elsif obj.respond_to?(resolver_method) method_to_call = resolver_method method_receiver = obj # Call the method with kwargs, if there are any if ruby_kwargs.any? obj.public_send(resolver_method, **ruby_kwargs) else obj.public_send(resolver_method) end elsif inner_object.is_a?(Hash) if @dig_keys inner_object.dig(*@dig_keys) elsif inner_object.key?(@method_sym) inner_object[@method_sym] elsif inner_object.key?(@method_str) || !inner_object.default_proc.nil? inner_object[@method_str] elsif @fallback_value != NOT_CONFIGURED @fallback_value else nil end elsif inner_object.respond_to?(@method_sym) method_to_call = @method_sym method_receiver = obj.object if ruby_kwargs.any? inner_object.public_send(@method_sym, **ruby_kwargs) else inner_object.public_send(@method_sym) end elsif @fallback_value != NOT_CONFIGURED @fallback_value else raise <<-ERR Failed to implement #{@owner.graphql_name}.#{@name}, tried: - `#{obj.class}##{resolver_method}`, which did not exist - `#{inner_object.class}##{@method_sym}`, which did not exist - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{inner_object}`, but it wasn't a Hash To implement this field, define one of the methods above (and check for typos), or supply a `fallback_value`. ERR end end else raise GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: query_ctx, field: self) end end rescue GraphQL::UnauthorizedFieldError => err err.field ||= self begin query_ctx.schema.(err) rescue GraphQL::ExecutionError => err err end rescue GraphQL::UnauthorizedError => err begin query_ctx.schema.(err) rescue GraphQL::ExecutionError => err err end rescue ArgumentError if method_receiver && method_to_call assert_satisfactory_implementation(method_receiver, method_to_call, method_args) end # if the line above doesn't raise, re-raise raise rescue GraphQL::ExecutionError => err err end |
#resolver ⇒ Class? Also known as: mutation
Returns The Resolver this field was derived from, if there is one.
62 63 64 |
# File 'lib/graphql/schema/field.rb', line 62 def resolver @resolver_class end |
#resolver_method ⇒ Symbol
Returns The method on the type to look up.
36 37 38 39 40 41 42 |
# File 'lib/graphql/schema/field.rb', line 36 def resolver_method if @resolver_class @resolver_class.resolver_method else @resolver_method end end |
#scoped? ⇒ Boolean
Returns if true, the return type's .scope_items
method will be applied to this field's return value.
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 |
# File 'lib/graphql/schema/field.rb', line 148 def scoped? if !@scope.nil? # The default was overridden @scope elsif @return_type_expr # Detect a list return type, but don't call `type` since that may eager-load an otherwise lazy-loaded type @return_type_expr.is_a?(Array) || (@return_type_expr.is_a?(String) && @return_type_expr.include?("[")) || connection? elsif @resolver_class resolver_type = @resolver_class.type_expr resolver_type.is_a?(Array) || (resolver_type.is_a?(String) && resolver_type.include?("[")) || connection? else false end end |
#visible?(context) ⇒ Boolean
601 602 603 604 605 606 607 |
# File 'lib/graphql/schema/field.rb', line 601 def visible?(context) if @resolver_class @resolver_class.visible?(context) else true end end |