graphql 2.5.22 → 2.5.23

data/lib/graphql/schema/resolver.rb

@@ -46,7 +46,7 @@ module GraphQL
         @prepared_arguments = nil
       end
 
-      attr_accessor :exec_result, :exec_index, :field_resolve_step
+      attr_accessor :exec_result, :exec_index, :field_resolve_step, :raw_arguments
 
       # @return [Object] The application object this field is being resolved on
       attr_accessor :object
@@ -66,7 +66,12 @@ module GraphQL
         q = context.query
         trace_objs = [object]
         q.current_trace.begin_execute_field(field, @prepared_arguments, trace_objs, q)
-        is_authed, new_return_value = authorized?(**@prepared_arguments)
+        begin
+          is_authed, new_return_value = authorized?(**@prepared_arguments)
+        rescue GraphQL::UnauthorizedError  => err
+          new_return_value = q.schema.unauthorized_object(err)
+          is_authed = true # the error was handled
+        end
 
         if (runner = @field_resolve_step.runner).resolves_lazies && runner.schema.lazy?(is_authed)
           is_authed, new_return_value = runner.schema.sync_lazy(is_authed)
@@ -74,13 +79,19 @@ module GraphQL
 
         result = if is_authed
           Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
+          if q.subscription? && @field.owner == context.schema.subscription
+            # This needs to use arguments without `loads:`
+            @original_arguments = @field_resolve_step.coerce_arguments(@field, @field_resolve_step.ast_node.arguments, false)
+          end
           call_resolve(@prepared_arguments)
+        elsif new_return_value.nil?
+          err = UnauthorizedFieldError.new(object: object, type: @field_resolve_step.parent_type, context: context, field: @field)
+          context.schema.unauthorized_field(err)
         else
           new_return_value
         end
         q = context.query
         q.current_trace.end_execute_field(field, @prepared_arguments, trace_objs, q, [result])
-
         exec_result[exec_index] = result
       rescue RuntimeError => err
         exec_result[exec_index] = err
@@ -198,6 +209,10 @@ module GraphQL
         authorize_arguments(args, inputs)
       end
 
+      def self.authorizes?(context)
+        self.instance_method(:authorized?).owner != GraphQL::Schema::Resolver
+      end
+
       # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
       #
       # By default, the error is re-raised and passed along to {{Schema.unauthorized_object}}.

data/lib/graphql/schema/subscription.rb

@@ -15,8 +15,6 @@ module GraphQL
       extend GraphQL::Schema::Resolver::HasPayloadType
       extend GraphQL::Schema::Member::HasFields
       NO_UPDATE = :no_update
-      # The generated payload type is required; If there's no payload,
-      # propagate null.
       null false
 
       # @api private

data/lib/graphql/schema/visibility/profile.rb

@@ -54,6 +54,9 @@ module GraphQL
           @cached_fields.default_proc = nil
           @cached_arguments.default_proc = nil
           @loadable_possible_types.default_proc = nil
+          @cached_field_result.default_proc = nil
+          @cached_field_result.each { |_, h| h.default_proc = nil }
+          @cached_type_result.default_proc = nil
           super
         end
 
@@ -122,6 +125,14 @@ module GraphQL
           end.compare_by_identity
 
           @loadable_possible_types = Hash.new { |h, union_type| h[union_type] = union_type.possible_types }.compare_by_identity
+
+          # Combined cache for field(owner, field_name) — avoids repeated kind check + parent lookup + visibility check
+          @cached_field_result = Hash.new { |h, owner|
+            h[owner] = Hash.new { |h2, field_name| h2[field_name] = compute_field(owner, field_name) }
+          }.compare_by_identity
+
+          # Cache for type(type_name) — avoids repeated get_type + visibility + referenced? checks
+          @cached_type_result = Hash.new { |h, type_name| h[type_name] = compute_type(type_name) }
         end
 
         def field_on_visible_interface?(field, owner)
@@ -149,58 +160,11 @@ module GraphQL
         end
 
         def type(type_name)
-          t = @visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
-          if t
-            if t.is_a?(Array)
-              vis_t = nil
-              t.each do |t_defn|
-                if @cached_visible[t_defn] && referenced?(t_defn)
-                  if vis_t.nil?
-                    vis_t = t_defn
-                  else
-                    raise_duplicate_definition(vis_t, t_defn)
-                  end
-                end
-              end
-              vis_t
-            else
-              if t && @cached_visible[t] && referenced?(t)
-                t
-              else
-                nil
-              end
-            end
-          end
+          @cached_type_result[type_name]
         end
 
         def field(owner, field_name)
-          f = if owner.kind.fields? && (field = @cached_parent_fields[owner][field_name])
-            field
-          elsif owner == query_root && (entry_point_field = @schema.introspection_system.entry_point(name: field_name))
-            entry_point_field
-          elsif (dynamic_field = @schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field
-          else
-            nil
-          end
-          if f.is_a?(Array)
-            visible_f = nil
-            f.each do |f_defn|
-              if @cached_visible_fields[owner][f_defn]
-
-                if visible_f.nil?
-                  visible_f = f_defn
-                else
-                  raise_duplicate_definition(visible_f, f_defn)
-                end
-              end
-            end
-            visible_f&.ensure_loaded
-          elsif f && @cached_visible_fields[owner][f.ensure_loaded]
-            f
-          else
-            nil
-          end
+          @cached_field_result[owner][field_name]
         end
 
         def fields(owner)
@@ -306,6 +270,7 @@ module GraphQL
         def preload
           load_all_types
           @all_types.each do |type_name, type_defn|
+            type(type_name)
             if type_defn.kind.fields?
               fields(type_defn).each do |f|
                 field(type_defn, f.graphql_name)
@@ -341,6 +306,60 @@ module GraphQL
 
         private
 
+        def compute_type(type_name)
+          t = @visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+          if t
+            if t.is_a?(Array)
+              vis_t = nil
+              t.each do |t_defn|
+                if @cached_visible[t_defn] && referenced?(t_defn)
+                  if vis_t.nil?
+                    vis_t = t_defn
+                  else
+                    raise_duplicate_definition(vis_t, t_defn)
+                  end
+                end
+              end
+              vis_t
+            else
+              if t && @cached_visible[t] && referenced?(t)
+                t
+              else
+                nil
+              end
+            end
+          end
+        end
+
+        def compute_field(owner, field_name)
+          f = if owner.kind.fields? && (field = @cached_parent_fields[owner][field_name])
+            field
+          elsif owner == query_root && (entry_point_field = @schema.introspection_system.entry_point(name: field_name))
+            entry_point_field
+          elsif (dynamic_field = @schema.introspection_system.dynamic_field(name: field_name))
+            dynamic_field
+          else
+            nil
+          end
+          if f.is_a?(Array)
+            visible_f = nil
+            f.each do |f_defn|
+              if @cached_visible_fields[owner][f_defn]
+                if visible_f.nil?
+                  visible_f = f_defn
+                else
+                  raise_duplicate_definition(visible_f, f_defn)
+                end
+              end
+            end
+            visible_f&.ensure_loaded
+          elsif f && @cached_visible_fields[owner][f.ensure_loaded]
+            f
+          else
+            nil
+          end
+        end
+
         def non_duplicate_items(definitions, visibility_cache)
           non_dups = []
           names = Set.new

data/lib/graphql/schema/wrapper.rb

@@ -13,7 +13,13 @@ module GraphQL
       end
 
       def unwrap
-        @of_type.unwrap
+        @unwrapped ||= @of_type.unwrap
+      end
+
+      def freeze
+        unwrap
+        to_type_signature
+        super
       end
 
       def ==(other)

data/lib/graphql/static_validation/base_visitor.rb

@@ -4,25 +4,26 @@ module GraphQL
     class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
-        @object_types = []
-        @directives = []
-        @field_definitions = []
-        @argument_definitions = []
-        @directive_definitions = []
+        @path_depth = 0
+        @current_object_type = nil
+        @parent_object_type = nil
+        @current_field_definition = nil
+        @current_argument_definition = nil
+        @parent_argument_definition = nil
+        @current_directive_definition = nil
         @context = context
         @types = context.query.types
         @schema = context.schema
+        @inline_fragment_paths = {}
+        @field_unwrapped_types = {}.compare_by_identity
         super(document)
       end
 
       attr_reader :context
 
-      # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
-      attr_reader :object_types
-
       # @return [Array<String>] The nesting of the current position in the AST
       def path
-        @path.dup
+        @path[0, @path_depth]
       end
 
       # Build a class to visit the AST and perform validation,
@@ -55,86 +56,125 @@ module GraphQL
       module ContextMethods
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
-          push_type(object_type)
-          @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          @current_object_type = object_type
+          @path[@path_depth] = "#{node.operation_type}#{node.name ? " #{node.name}" : ""}"
+          @path_depth += 1
           super
-          @object_types.pop
-          @path.pop
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
         def on_fragment_definition(node, parent)
-          on_fragment_with_type(node) do
-            @path.push("fragment #{node.name}")
-            super
+          object_type = if node.type
+            @types.type(node.type.name)
+          else
+            @current_object_type
           end
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          @current_object_type = object_type
+          @path[@path_depth] = "fragment #{node.name}"
+          @path_depth += 1
+          super
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
+        INLINE_FRAGMENT_NO_TYPE = "..."
+
         def on_inline_fragment(node, parent)
-          on_fragment_with_type(node) do
-            @path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
-            super
+          if node.type
+            object_type = @types.type(node.type.name)
+            @path[@path_depth] = @inline_fragment_paths[node.type.name] ||= -"... on #{node.type.to_query_string}"
+            @path_depth += 1
+          else
+            object_type = @current_object_type
+            @path[@path_depth] = INLINE_FRAGMENT_NO_TYPE
+            @path_depth += 1
           end
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          @current_object_type = object_type
+          super
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
         def on_field(node, parent)
-          parent_type = @object_types.last
+          parent_type = @current_object_type
           field_definition = @types.field(parent_type, node.name)
-          @field_definitions.push(field_definition)
-          if !field_definition.nil?
-            next_object_type = field_definition.type.unwrap
-            push_type(next_object_type)
+          prev_field_definition = @current_field_definition
+          @current_field_definition = field_definition
+          prev_parent_ot = @parent_object_type
+          @parent_object_type = @current_object_type
+          if field_definition
+            @current_object_type = @field_unwrapped_types[field_definition] ||= field_definition.type.unwrap
           else
-            push_type(nil)
+            @current_object_type = nil
           end
-          @path.push(node.alias || node.name)
+          @path[@path_depth] = node.alias || node.name
+          @path_depth += 1
           super
-          @field_definitions.pop
-          @object_types.pop
-          @path.pop
+          @current_field_definition = prev_field_definition
+          @current_object_type = @parent_object_type
+          @parent_object_type = prev_parent_ot
+          @path_depth -= 1
         end
 
         def on_directive(node, parent)
           directive_defn = @context.schema_directives[node.name]
-          @directive_definitions.push(directive_defn)
+          prev_directive_definition = @current_directive_definition
+          @current_directive_definition = directive_defn
           super
-          @directive_definitions.pop
+          @current_directive_definition = prev_directive_definition
         end
 
         def on_argument(node, parent)
-          argument_defn = if (arg = @argument_definitions.last)
+          argument_defn = if (arg = @current_argument_definition)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
               @types.argument(arg_type, node.name)
             else
               nil
             end
-          elsif (directive_defn = @directive_definitions.last)
+          elsif (directive_defn = @current_directive_definition)
             @types.argument(directive_defn, node.name)
-          elsif (field_defn = @field_definitions.last)
+          elsif (field_defn = @current_field_definition)
             @types.argument(field_defn, node.name)
           else
             nil
           end
 
-          @argument_definitions.push(argument_defn)
-          @path.push(node.name)
+          prev_parent = @parent_argument_definition
+          @parent_argument_definition = @current_argument_definition
+          @current_argument_definition = argument_defn
+          @path[@path_depth] = node.name
+          @path_depth += 1
           super
-          @argument_definitions.pop
-          @path.pop
+          @current_argument_definition = @parent_argument_definition
+          @parent_argument_definition = prev_parent
+          @path_depth -= 1
         end
 
         def on_fragment_spread(node, parent)
-          @path.push("... #{node.name}")
+          @path[@path_depth] = "... #{node.name}"
+          @path_depth += 1
           super
-          @path.pop
+          @path_depth -= 1
         end
 
         def on_input_object(node, parent)
-          arg_defn = @argument_definitions.last
+          arg_defn = @current_argument_definition
           if arg_defn && arg_defn.type.list?
-            @path.push(parent.children.index(node))
+            @path[@path_depth] = parent.children.index(node)
+            @path_depth += 1
             super
-            @path.pop
+            @path_depth -= 1
           else
             super
           end
@@ -142,48 +182,32 @@ module GraphQL
 
         # @return [GraphQL::BaseType] The current object type
         def type_definition
-          @object_types.last
+          @current_object_type
         end
 
         # @return [GraphQL::BaseType] The type which the current type came from
         def parent_type_definition
-          @object_types[-2]
+          @parent_object_type
         end
 
         # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
         def field_definition
-          @field_definitions.last
+          @current_field_definition
         end
 
         # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
         def directive_definition
-          @directive_definitions.last
+          @current_directive_definition
         end
 
         # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
         def argument_definition
-          # Don't get the _last_ one because that's the current one.
-          # Get the second-to-last one, which is the parent of the current one.
-          @argument_definitions[-2]
+          # Return the parent argument definition (not the current one).
+          @parent_argument_definition
         end
 
         private
 
-        def on_fragment_with_type(node)
-          object_type = if node.type
-            @types.type(node.type.name)
-          else
-            @object_types.last
-          end
-          push_type(object_type)
-          yield(node)
-          @object_types.pop
-          @path.pop
-        end
-
-        def push_type(t)
-          @object_types.push(t)
-        end
       end
 
       private
@@ -192,7 +216,7 @@ module GraphQL
         if @context.too_many_errors?
           throw :too_many_validation_errors
         end
-        error.path ||= (path || @path.dup)
+        error.path ||= (path || @path[0, @path_depth])
         context.errors << error
       end
 

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -12,7 +12,7 @@ module GraphQL
           return
         end
 
-        if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
+        if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path_depth) == @path[0, @path_depth] }
           parent_defn = parent_definition(parent)
 
           if parent_defn && (arg_defn = @types.argument(parent_defn, node.name))

data/lib/graphql/static_validation/rules/argument_names_are_unique.rb

@@ -16,12 +16,24 @@ module GraphQL
 
       def validate_arguments(node)
         argument_defns = node.arguments
-        if !argument_defns.empty?
-          args_by_name = Hash.new { |h, k| h[k] = [] }
-          argument_defns.each { |a| args_by_name[a.name] << a }
-          args_by_name.each do |name, defns|
-            if defns.size > 1
-              add_error(GraphQL::StaticValidation::ArgumentNamesAreUniqueError.new("There can be only one argument named \"#{name}\"", nodes: defns, name: name))
+        if argument_defns.size > 1
+          seen = {}
+          argument_defns.each do |a|
+            name = a.name
+            if seen.key?(name)
+              prev = seen[name]
+              if prev.is_a?(Array)
+                prev << a
+              else
+                seen[name] = [prev, a]
+              end
+            else
+              seen[name] = a
+            end
+          end
+          seen.each do |name, val|
+            if val.is_a?(Array)
+              add_error(GraphQL::StaticValidation::ArgumentNamesAreUniqueError.new("There can be only one argument named \"#{name}\"", nodes: val, name: name))
             end
           end
         end

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -10,9 +10,12 @@ module GraphQL
         elsif parent_defn
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, parent_defn)
-          arg_names = context.types.arguments(parent_defn).map(&:graphql_name)
+          suggestion = if @schema.did_you_mean
+            arg_names = context.types.arguments(parent_defn).map(&:graphql_name)
+            context.did_you_mean_suggestion(node.name, arg_names)
+          end
           add_error(GraphQL::StaticValidation::ArgumentsAreDefinedError.new(
-            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'#{context.did_you_mean_suggestion(node.name, arg_names)}",
+            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'#{suggestion}",
             nodes: node,
             name: error_arg_name,
             type: kind_of_node,

data/lib/graphql/static_validation/rules/directives_are_defined.rb

@@ -10,9 +10,12 @@ module GraphQL
         if !@types.directive_exists?(node.name)
           @directives_are_defined_errors_by_name ||= {}
           error = @directives_are_defined_errors_by_name[node.name] ||= begin
-            @directive_names ||= @types.directives.map(&:graphql_name)
+            suggestion = if @schema.did_you_mean
+              @directive_names ||= @types.directives.map(&:graphql_name)
+              context.did_you_mean_suggestion(node.name, @directive_names)
+            end
             err = GraphQL::StaticValidation::DirectivesAreDefinedError.new(
-              "Directive @#{node.name} is not defined#{context.did_you_mean_suggestion(node.name, @directive_names)}",
+              "Directive @#{node.name} is not defined#{suggestion}",
               nodes: [],
               directive: node.name
             )

data/lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     module FieldsAreDefinedOnType
       def on_field(node, parent)
-        parent_type = @object_types[-2]
+        parent_type = @parent_object_type
         field = context.query.types.field(parent_type, node.name)
 
         if field.nil?
@@ -14,8 +14,9 @@ module GraphQL
               node_name: parent_type.graphql_name
             ))
           else
-            possible_fields = possible_fields(context, parent_type)
-            suggestion = context.did_you_mean_suggestion(node.name, possible_fields)
+            suggestion = if @schema.did_you_mean
+              context.did_you_mean_suggestion(node.name, possible_fields(context, parent_type))
+            end
             message = "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'#{suggestion}"
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
               message,

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -7,8 +7,7 @@ module GraphQL
       include GraphQL::StaticValidation::Error::ErrorHelper
 
       def on_field(node, parent)
-        field_defn = field_definition
-        if validate_field_selections(node, field_defn.type.unwrap)
+        if validate_field_selections(node, @current_object_type)
           super
         end
       end
@@ -23,6 +22,17 @@ module GraphQL
 
 
       def validate_field_selections(ast_node, resolved_type)
+        # Fast paths for the two most common cases:
+        # 1. Leaf type with no selections (scalars, enums) — most fields
+        # 2. Non-leaf type with selections (objects, interfaces)
+        if resolved_type
+          if ast_node.selections.empty?
+            return true if resolved_type.kind.leaf?
+          else
+            return true unless resolved_type.kind.leaf?
+          end
+        end
+
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.leaf?