Resolver#initialize argument cache misses arguments added by field extensions

[szluzero]

Describe the bug

When a FieldExtension adds arguments to a mutation field via apply, those arguments are not included in the @arguments_by_keyword cache built in Resolver#initialize. This means context.types.argument(mutation_class, name) returns nil for extension-added arguments, even though they are valid schema arguments on the field.

The root cause is this caching in Resolver#initialize:

@arguments_by_keyword = {}
context.types.arguments(self.class).each do |arg|
  @arguments_by_keyword[arg.keyword] = arg
end

context.types.arguments(self.class) only returns arguments defined directly on the resolver class — not arguments added to the field by extensions.

Versions

graphql version: 2.5.15
rails (or other framework): Rails (version not specific to the bug)
other applicable versions: N/A

GraphQL schema

class ExtraInput < GraphQL::Schema::InputObject
  argument :value, String, required: false
end

class MyExtension < GraphQL::Schema::FieldExtension
  def apply
    field.argument(:extra, ExtraInput, required: false)
  end
end

class MyMutation < GraphQL::Schema::Mutation
  argument :input, String, required: false
  extension(MyExtension)

  field :result, String

  def resolve(input: nil, extra: nil)
    # extra is received correctly at resolve time,
    # but is not in @arguments_by_keyword
    { result: "ok" }
  end
end

class MutationRoot < GraphQL::Schema::Object
  field :my_mutation, mutation: MyMutation
end

class MySchema < GraphQL::Schema
  mutation MutationRoot
end

GraphQL query

mutation {
  myMutation(input: "test", extra: { value: "hello" }) {
    result
  }
}

Steps to reproduce

1. Define a FieldExtension that adds an argument via field.argument(...) in apply
2. Attach the extension to a mutation with extension(MyExtension)
3. In any code that runs during resolution, call context.types.argument(MyMutation, "extra") — it returns nil
4. Alternatively, inspect @arguments_by_keyword inside the resolver — :extra is missing

Expected behavior

context.types.arguments(self.class) (and by extension context.types.argument(self.class, name)) should include arguments added by field extensions, since those arguments are part of the field's actual schema signature and are accepted at query time.

Actual behavior

Extension-added arguments are missing from @arguments_by_keyword and from context.types.argument lookups against the resolver class. The arguments work correctly at resolve time (they're passed as keyword args), but any introspection or validation code that uses the types API to look up arguments on the mutation class can't find them.

Additional context

A workaround is to look up arguments via the schema field instead of the resolver class:

mutation_root = context.schema.mutation
mutation_field = context.types.field(mutation_root, "myMutation")
context.types.argument(mutation_field, "extra") # => returns the argument

This correctly finds extension-added arguments, but requires traversing the schema manually rather than using the resolver class directly.

[swalkinshaw]

I'll also add that context.types.arguments(self.class) seemed weird to me because it's a cache for Ruby classes and not just type classes but I think it might be conflating things? My assumption is that the context.types interface should represent the schema and not just internal classes that might not be directly present in a schema (like resolver/mutation classes).

[rmosolgo]

Hey, thanks for the detailed report and sorry for the trouble. I guess this never came up with ConnectionExtension because it actually removes the arguments that it adds before passing them along to the resolver anyways. Actually, I see what you're saying in the OP -- def resolve does receive the right arguments, so it probably never came up because the user-facing surface of this bug is so small.

I pushed a fix in #5573 similar to your suggestion.

The only way I could figure out how this affected the public API was loads: ... arguments. What that how you discovered it? Or is there some other public API that draws on @arguments_by_keyword?

[swalkinshaw]

@rmosolgo our mutations return [UserError] which have a path to the input field(s). Internally we have logic to validate that those point to an actual path and report if not. In that context we only have the mutation resolver class reference, so we use context.types.argument(MutationResolverClass, path).

[rmosolgo]

Oh, I see. So #5573 won't actually help you, but you could do a two-stage lookup (.field(...) -> .argument(...)) as shown in "additional context" in the OP, right? Did something like that work for your case?

Another possibility here is to change how Resolver extensions are added to the fields that use the resolver. Currently, the Resolver class doesn't actually do anything with its extensions except store them. Later, when the resolver is attached to a field, the extension is forwarded to the field:

graphql-ruby/lib/graphql/schema/field.rb

Lines 343 to 345 in b79712c

	if resolver_class && !resolver_class.extensions.empty?
	self.extensions(resolver_class.extensions)
	end

If changing your lookup doesn't work, it might also be possible to actually apply extensions to resolver classes.

[swalkinshaw]

We added the two stage lookup as an initial workaround but we'd rather avoid that. Plus we don't even have the mutation field available so we do MutationResolver.graphql_name.camelize(:lower) which usually works by convention, but might not always be the mutation field name.