graphql 2.3.7 → 2.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13269b31415c3c837e80ec0097b8162c65035119f16860a18012b15e71ace318
-  data.tar.gz: a3d1a936954352bd4ac46aab7f682377f3c219c477db32a65eb414d04655f099
+  metadata.gz: aa940f82a3f79bd899de908905d6656c5a4b60b6174f70380ed42d3643992085
+  data.tar.gz: 3c20f6255693b62acc10cb4d9069c6433d7548a31f9ae2a8c4554f6d91646dc9
 SHA512:
-  metadata.gz: 721413cdc90187b7348514ea90d65f25a22a88551c3665dee7ff7f5d986b515f535bb147fedc72fbee4942ac5fdea2f9c1ffb38f5751706a98cecef98e7f94e6
-  data.tar.gz: 4a1b47909ffbc71665ee2451002da4e2633dd010775b49e66e7a98068b73e60e5dc3c37e2491ee10f4f52bacc24d0c38f19d31a2cc9f436e8af2ebd6fac73d03
+  metadata.gz: e92413d9e9a3e5fc507ef4522167aa2268f6c5645847f6c5f7b97bfad1a94cd043048d2a7a7cf7c3df6ff748e76266a63101c96c25bf0fd3601a1bd8f5e07311
+  data.tar.gz: 58ca270e89fa01dd0bac02cfd559250b2088979bd6a7a57c2c722196d1bf7e824c35f29b3d1e98ffe390157d2bebcedbc3e33cddec21cb55e0abe4644d3275dc

data/lib/graphql/analysis/field_usage.rb

@@ -72,7 +72,7 @@ module GraphQL
       end
 
       def extract_deprecated_enum_value(enum_type, value)
-        enum_value = @query.warden.enum_values(enum_type).find { |ev| ev.value == value }
+        enum_value = @query.types.enum_values(enum_type).find { |ev| ev.value == value }
         if enum_value&.deprecation_reason
           @used_deprecated_enum_values << enum_value.path
         end

data/lib/graphql/analysis/query_complexity.rb

@@ -98,7 +98,7 @@ module GraphQL
         possible_scope_types.keys.each do |possible_scope_type|
           next unless possible_scope_type.kind.abstract?
 
-          query.possible_types(possible_scope_type).each do |impl_type|
+          query.types.possible_types(possible_scope_type).each do |impl_type|
             possible_scope_types[impl_type] ||= true
           end
           possible_scope_types.delete(possible_scope_type)
@@ -123,8 +123,8 @@ module GraphQL
       def types_intersect?(query, a, b)
         return true if a == b
 
-        a_types = query.possible_types(a)
-        query.possible_types(b).any? { |t| a_types.include?(t) }
+        a_types = query.types.possible_types(a)
+        query.types.possible_types(b).any? { |t| a_types.include?(t) }
       end
 
       # A hook which is called whenever a field's max complexity is calculated.

data/lib/graphql/analysis/visitor.rb

@@ -21,6 +21,7 @@ module GraphQL
         @rescued_errors = []
         @query = query
         @schema = query.schema
+        @types = query.types
         @response_path = []
         @skip_stack = [false]
         super(query.selected_operation)
@@ -131,7 +132,7 @@ module GraphQL
         @response_path.push(node.alias || node.name)
         parent_type = @object_types.last
         # This could be nil if the previous field wasn't found:
-        field_definition = parent_type && @schema.get_field(parent_type, node.name, @query.context)
+        field_definition = parent_type && @types.field(parent_type, node.name)
         @field_definitions.push(field_definition)
         if !field_definition.nil?
           next_object_type = field_definition.type.unwrap
@@ -167,14 +168,14 @@ module GraphQL
         argument_defn = if (arg = @argument_definitions.last)
           arg_type = arg.type.unwrap
           if arg_type.kind.input_object?
-            arg_type.get_argument(node.name, @query.context)
+            @types.argument(arg_type, node.name)
           else
             nil
           end
         elsif (directive_defn = @directive_definitions.last)
-          directive_defn.get_argument(node.name, @query.context)
+          @types.argument(directive_defn, node.name)
         elsif (field_defn = @field_definitions.last)
-          field_defn.get_argument(node.name, @query.context)
+          @types.argument(field_defn, node.name)
         else
           nil
         end
@@ -245,7 +246,7 @@ module GraphQL
         fragment_def = query.fragments[fragment_spread.name]
 
         object_type = if fragment_def.type
-          @query.warden.get_type(fragment_def.type.name)
+          @types.type(fragment_def.type.name)
         else
           object_types.last
         end
@@ -268,7 +269,7 @@ module GraphQL
 
       def on_fragment_with_type(node)
         object_type = if node.type
-          @query.warden.get_type(node.type.name)
+          @types.type(node.type.name)
         else
           @object_types.last
         end

data/lib/graphql/execution/interpreter/runtime.rb

@@ -160,9 +160,9 @@ module GraphQL
               case node
               when GraphQL::Language::Nodes::InlineFragment
                 if node.type
-                  type_defn = schema.get_type(node.type.name, context)
+                  type_defn = query.types.type(node.type.name)
 
-                  if query.warden.possible_types(type_defn).include?(owner_type)
+                  if query.types.possible_types(type_defn).include?(owner_type)
                     result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
                     if !result.equal?(next_selections)
                       selections_to_run = result
@@ -177,8 +177,8 @@ module GraphQL
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
-                type_defn = query.get_type(fragment_def.type.name)
-                if query.warden.possible_types(type_defn).include?(owner_type)
+                type_defn = query.types.type(fragment_def.type.name)
+                if query.types.possible_types(type_defn).include?(owner_type)
                   result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
                   if !result.equal?(next_selections)
                     selections_to_run = result
@@ -245,7 +245,7 @@ module GraphQL
           end
           field_name = ast_node.name
           owner_type = selections_result.graphql_result_type
-          field_defn = query.warden.get_field(owner_type, field_name)
+          field_defn = query.types.field(owner_type, field_name)
 
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           runtime_state = get_current_runtime_state
@@ -579,7 +579,7 @@ module GraphQL
                 resolved_value = value
               end
 
-              possible_types = query.possible_types(current_type)
+              possible_types = query.types.possible_types(current_type)
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
                 err_class = current_type::UnresolvedTypeError

data/lib/graphql/execution/lookahead.rb

@@ -108,16 +108,16 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_defn = case field_name
         when String
-          @query.get_field(selected_type, field_name)
+          @query.types.field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
           all_fields = if selected_type.kind.fields?
-            @query.warden.fields(selected_type)
+            @query.types.fields(selected_type)
           else
             # Handle unions by checking possible
-            @query.warden
+            @query.types
               .possible_types(selected_type)
-              .map { |t| @query.warden.fields(t) }
+              .map { |t| @query.types.fields(t) }
               .tap(&:flatten!)
           end
 
@@ -128,7 +128,7 @@ module GraphQL
             # Symbol#name is only present on 3.0+
             sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
             guessed_name = Schema::Member::BuildType.camelize(sym_s)
-            @query.get_field(selected_type, guessed_name)
+            @query.types.field(selected_type, guessed_name)
           end
         end
         lookahead_for_selection(next_field_defn, selected_type, arguments)
@@ -144,7 +144,7 @@ module GraphQL
         alias_node = lookup_alias_node(ast_nodes, alias_name)
         return NULL_LOOKAHEAD unless alias_node
 
-        next_field_defn = @query.get_field(selected_type, alias_node.name)
+        next_field_defn = @query.types.field(selected_type, alias_node.name)
 
         alias_arguments = @query.arguments_for(alias_node, next_field_defn)
         if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
@@ -183,7 +183,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = @query.get_field(type, ast_nodes.first.name)
+            field_defn = @query.types.field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -266,7 +266,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = @query.get_field(selected_type, ast_selection.name)
+              field_defn = @query.types.field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -276,14 +276,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.get_type(t.name)
+              on_type = @query.types.type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
-            on_type = @query.get_type(frag_defn.type.name)
+            on_type = @query.types.type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else

data/lib/graphql/introspection/directive_type.rb

@@ -22,7 +22,7 @@ module GraphQL
       field :is_repeatable, Boolean, method: :repeatable?
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/entry_points.rb

@@ -15,8 +15,8 @@ module GraphQL
       end
 
       def __type(name:)
-        if context.warden.reachable_type?(name)
-          context.warden.get_type(name)
+        if context.types.reachable_type?(name)
+          context.types.type(name)
         elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
           type
         else

data/lib/graphql/introspection/field_type.rb

@@ -19,7 +19,7 @@ module GraphQL
       end
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/schema_type.rb

@@ -20,31 +20,26 @@ module GraphQL
       end
 
       def types
-        types = context.warden.reachable_types + context.schema.extra_types
+        query_types = context.types.all_types
+        types = query_types + context.schema.extra_types
         types.sort_by!(&:graphql_name)
         types
       end
 
       def query_type
-        permitted_root_type("query")
+        @context.types.query_root
       end
 
       def mutation_type
-        permitted_root_type("mutation")
+        @context.types.mutation_root
       end
 
       def subscription_type
-        permitted_root_type("subscription")
+        @context.types.subscription_root
       end
 
       def directives
-        @context.warden.directives
-      end
-
-      private
-
-      def permitted_root_type(op_type)
-        @context.warden.root_type_for_operation(op_type)
+        @context.types.directives
       end
     end
   end

data/lib/graphql/introspection/type_type.rb

@@ -52,7 +52,7 @@ module GraphQL
         if !@object.kind.enum?
           nil
         else
-          enum_values = @context.warden.enum_values(@object)
+          enum_values = @context.types.enum_values(@object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -64,7 +64,7 @@ module GraphQL
 
       def interfaces
         if @object.kind.object? || @object.kind.interface?
-          @context.warden.interfaces(@object).sort_by(&:graphql_name)
+          @context.types.interfaces(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -72,7 +72,7 @@ module GraphQL
 
       def input_fields(include_deprecated:)
         if @object.kind.input_object?
-          args = @context.warden.arguments(@object)
+          args = @context.types.arguments(@object)
           args = args.reject(&:deprecation_reason) unless include_deprecated
           args
         else
@@ -82,7 +82,7 @@ module GraphQL
 
       def possible_types
         if @object.kind.abstract?
-          @context.warden.possible_types(@object).sort_by(&:graphql_name)
+          @context.types.possible_types(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -92,7 +92,7 @@ module GraphQL
         if !@object.kind.fields?
           nil
         else
-          fields = @context.warden.fields(@object)
+          fields = @context.types.fields(@object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end

data/lib/graphql/language/document_from_schema_definition.rb

@@ -24,15 +24,8 @@ module GraphQL
         @include_built_in_directives = include_built_in_directives
         @include_one_of = false
 
-        schema_context = schema.context_class.new(query: nil, schema: schema, values: context)
-
-
-        @warden = @schema.warden_class.new(
-          schema: @schema,
-          context: schema_context,
-        )
-
-        schema_context.warden = @warden
+        dummy_query = @schema.query_class.new(@schema, "{ __typename }", validate: false, context: context)
+        @types = dummy_query.types # rubocop:disable Development/ContextIsPassedCop
       end
 
       def document
@@ -44,9 +37,9 @@ module GraphQL
       def build_schema_node
         if !schema_respects_root_name_conventions?(@schema)
           GraphQL::Language::Nodes::SchemaDefinition.new(
-            query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
-            mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
-            subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
+            query:  @types.query_root&.graphql_name,
+            mutation: @types.mutation_root&.graphql_name,
+            subscription: @types.subscription_root&.graphql_name,
             directives: definition_directives(@schema, :schema_directives)
           )
         else
@@ -57,7 +50,7 @@ module GraphQL
       end
 
       def build_object_type_node(object_type)
-        ints = warden.interfaces(object_type)
+        ints = @types.interfaces(object_type)
         if ints.any?
           ints.sort_by!(&:graphql_name)
           ints.map! { |iface| build_type_name_node(iface) }
@@ -66,7 +59,7 @@ module GraphQL
         GraphQL::Language::Nodes::ObjectTypeDefinition.new(
           name: object_type.graphql_name,
           interfaces: ints,
-          fields: build_field_nodes(warden.fields(object_type)),
+          fields: build_field_nodes(@types.fields(object_type)),
           description: object_type.description,
           directives: directives(object_type),
         )
@@ -75,7 +68,7 @@ module GraphQL
       def build_field_node(field)
         GraphQL::Language::Nodes::FieldDefinition.new(
           name: field.graphql_name,
-          arguments: build_argument_nodes(warden.arguments(field)),
+          arguments: build_argument_nodes(@types.arguments(field)),
           type: build_type_name_node(field.type),
           description: field.description,
           directives: directives(field),
@@ -86,7 +79,7 @@ module GraphQL
         GraphQL::Language::Nodes::UnionTypeDefinition.new(
           name: union_type.graphql_name,
           description: union_type.description,
-          types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
+          types: @types.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
           directives: directives(union_type),
         )
       end
@@ -94,9 +87,9 @@ module GraphQL
       def build_interface_type_node(interface_type)
         GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
           name: interface_type.graphql_name,
-          interfaces: warden.interfaces(interface_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
+          interfaces: @types.interfaces(interface_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
           description: interface_type.description,
-          fields: build_field_nodes(warden.fields(interface_type)),
+          fields: build_field_nodes(@types.fields(interface_type)),
           directives: directives(interface_type),
         )
       end
@@ -104,7 +97,7 @@ module GraphQL
       def build_enum_type_node(enum_type)
         GraphQL::Language::Nodes::EnumTypeDefinition.new(
           name: enum_type.graphql_name,
-          values: warden.enum_values(enum_type).sort_by(&:graphql_name).map do |enum_value|
+          values: @types.enum_values(enum_type).sort_by(&:graphql_name).map do |enum_value|
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
@@ -149,7 +142,7 @@ module GraphQL
       def build_input_object_node(input_object)
         GraphQL::Language::Nodes::InputObjectTypeDefinition.new(
           name: input_object.graphql_name,
-          fields: build_argument_nodes(warden.arguments(input_object)),
+          fields: build_argument_nodes(@types.arguments(input_object)),
           description: input_object.description,
           directives: directives(input_object),
         )
@@ -159,7 +152,7 @@ module GraphQL
         GraphQL::Language::Nodes::DirectiveDefinition.new(
           name: directive.graphql_name,
           repeatable: directive.repeatable?,
-          arguments: build_argument_nodes(warden.arguments(directive)),
+          arguments: build_argument_nodes(@types.arguments(directive)),
           locations: build_directive_location_nodes(directive.locations),
           description: directive.description,
         )
@@ -204,7 +197,7 @@ module GraphQL
         when "INPUT_OBJECT"
           GraphQL::Language::Nodes::InputObject.new(
             arguments: default_value.to_h.map do |arg_name, arg_value|
-              args = @warden.arguments(type)
+              args = @types.arguments(type)
               arg = args.find { |a| a.keyword.to_s == arg_name.to_s }
               if arg.nil?
                 raise ArgumentError, "No argument definition on #{type.graphql_name} for argument: #{arg_name.inspect} (expected one of: #{args.map(&:keyword)})"
@@ -260,13 +253,13 @@ module GraphQL
       end
 
       def build_definition_nodes
-        dirs_to_build = warden.directives
+        dirs_to_build = @types.directives
         if !include_built_in_directives
           dirs_to_build = dirs_to_build.reject { |directive| directive.default_directive? }
         end
         definitions = build_directive_nodes(dirs_to_build)
-
-        type_nodes = build_type_definition_nodes(warden.reachable_types + schema.extra_types)
+        all_types = @types.all_types
+        type_nodes = build_type_definition_nodes(all_types + schema.extra_types)
         if @include_one_of
           # This may have been set to true when iterating over all types
           definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
@@ -351,7 +344,7 @@ module GraphQL
         dirs
       end
 
-      attr_reader :schema, :warden, :always_include_schema,
+      attr_reader :schema, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end
   end

data/lib/graphql/language/lexer.rb

@@ -345,17 +345,14 @@ module GraphQL
       def self.tokenize(string)
         lexer = GraphQL::Language::Lexer.new(string)
         tokens = []
-        prev_token = nil
         while (token_name = lexer.advance)
           new_token = [
             token_name,
             lexer.line_number,
             lexer.column_number,
             lexer.debug_token_value(token_name),
-            prev_token,
           ]
           tokens << new_token
-          prev_token = new_token
         end
         tokens
       end

data/lib/graphql/language/sanitized_printer.rb

@@ -113,7 +113,7 @@ module GraphQL
       end
 
       def print_field(field, indent: "")
-        @current_field = query.get_field(@current_type, field.name)
+        @current_field = query.types.field(@current_type, field.name)
         old_type = @current_type
         @current_type = @current_field.type.unwrap
         super

data/lib/graphql/language.rb

@@ -9,7 +9,6 @@ require "graphql/language/nodes"
 require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/static_visitor"
-require "graphql/language/token"
 require "graphql/language/visitor"
 require "graphql/language/definition_slice"
 require "strscan"

data/lib/graphql/query/context.rb

@@ -84,6 +84,10 @@ module GraphQL
 
       def_delegators :@query, :trace, :interpreter?
 
+      def types
+        @query.types
+      end
+
       RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`

data/lib/graphql/query/null_context.rb

@@ -30,6 +30,10 @@ module GraphQL
       def interpreter?
         true
       end
+
+      def types
+        @types ||= GraphQL::Schema::Warden::SchemaSubset.new(@warden)
+      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -95,12 +95,24 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil, use_schema_subset: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
       @context = schema.context_class.new(query: self, values: context)
-      @warden = warden
+
+      if use_schema_subset.nil?
+        use_schema_subset = warden ? false : schema.use_schema_subset?
+      end
+
+      if use_schema_subset
+        @schema_subset = @schema.subset_class.new(self)
+        @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
+      else
+        @schema_subset = nil
+        @warden = warden
+      end
+
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
@@ -195,7 +207,14 @@ module GraphQL
     def lookahead
       @lookahead ||= begin
         ast_node = selected_operation
-        root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
+        root_type = case ast_node.operation_type
+        when nil, "query"
+          types.query_root # rubocop:disable Development/ContextIsPassedCop
+        when "mutation"
+          types.mutation_root # rubocop:disable Development/ContextIsPassedCop
+        when "subscription"
+          types.subscription_root # rubocop:disable Development/ContextIsPassedCop
+        end
         GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
@@ -330,6 +349,10 @@ module GraphQL
 
     def_delegators :warden, :get_type, :get_field, :possible_types, :root_type_for_operation
 
+    def types
+      @schema_subset || warden.schema_subset
+    end
+
     # @param abstract_type [GraphQL::UnionType, GraphQL::InterfaceType]
     # @param value [Object] Any runtime value
     # @return [GraphQL::ObjectType, nil] The runtime type of `value` from {Schema#resolve_type}

data/lib/graphql/schema/always_visible.rb

@@ -4,6 +4,7 @@ module GraphQL
     class AlwaysVisible
       def self.use(schema, **opts)
         schema.warden_class = GraphQL::Schema::Warden::NullWarden
+        schema.subset_class = GraphQL::Schema::Warden::NullWarden::NullSubset
       end
     end
   end

data/lib/graphql/schema/enum.rb

@@ -130,7 +130,7 @@ module GraphQL
         end
 
         def validate_non_null_input(value_name, ctx, max_errors: nil)
-          allowed_values = ctx.warden.enum_values(self)
+          allowed_values = ctx.types.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 
           if matching_value.nil?
@@ -141,8 +141,8 @@ module GraphQL
         end
 
         def coerce_result(value, ctx)
-          warden = ctx.warden
-          all_values = warden ? warden.enum_values(self) : values.each_value
+          types = ctx.types
+          all_values = types ? types.enum_values(self) : values.each_value
           enum_value = all_values.find { |val| val.value == value }
           if enum_value
             enum_value.graphql_name
@@ -152,7 +152,7 @@ module GraphQL
         end
 
         def coerce_input(value_name, ctx)
-          all_values = ctx.warden ? ctx.warden.enum_values(self) : values.each_value
+          all_values = ctx.types ? ctx.types.enum_values(self) : values.each_value
 
           if v = all_values.find { |val| val.graphql_name == value_name }
             v.value

data/lib/graphql/schema/field.rb

@@ -618,7 +618,7 @@ module GraphQL
               using_arg_values = false
             end
 
-            args = context.warden.arguments(self)
+            args = context.types.arguments(self)
             args.each do |arg|
               arg_key = arg.keyword
               if arg_values.key?(arg_key)

data/lib/graphql/schema/has_single_input_argument.rb

@@ -149,7 +149,8 @@ module GraphQL
 
       def authorize_arguments(args, values)
         # remove the `input` wrapper to match values
-        input_args = args["input"].type.unwrap.arguments(context)
+        input_type = args.find { |a| a.graphql_name == "input" }.type.unwrap
+        input_args = context.types.arguments(input_type)
         super(input_args, values)
       end
     end