graphql 2.5.11 → 2.6.10

data/lib/graphql/schema/resolver.rb

@@ -23,6 +23,7 @@ module GraphQL
       # Really we only need description & comment from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasAuthorization
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
@@ -45,8 +46,10 @@ module GraphQL
         @prepared_arguments = nil
       end
 
+      attr_accessor :exec_result, :exec_index, :field_resolve_step, :raw_arguments
+
       # @return [Object] The application object this field is being resolved on
-      attr_reader :object
+      attr_accessor :object
 
       # @return [GraphQL::Query::Context]
       attr_reader :context
@@ -54,6 +57,74 @@ module GraphQL
       # @return [GraphQL::Schema::Field]
       attr_reader :field
 
+      attr_writer :prepared_arguments
+
+      def call
+        q = context.query
+        trace_objs = [object]
+        q.current_trace.begin_execute_field(field, @prepared_arguments, trace_objs, q)
+        is_ready = ready?(**@prepared_arguments)
+        runner = @field_resolve_step.runner
+        if runner.resolves_lazies && runner.schema.lazy?(is_ready)
+          is_ready, new_return_value = runner.schema.sync_lazy(is_ready)
+        end
+
+        if is_ready.is_a?(Array)
+          is_ready, new_return_value = is_ready
+          if is_ready != false
+            raise "Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{new_return_value.inspect}]"
+          else
+            new_return_value
+          end
+        end
+
+        if is_ready
+          begin
+            is_authed, new_return_value = authorized?(**@prepared_arguments)
+          rescue GraphQL::UnauthorizedError  => err
+            new_return_value = q.schema.unauthorized_object(err)
+            is_authed = false
+          end
+        end
+
+        if runner.resolves_lazies && runner.schema.lazy?(is_authed)
+          is_authed, new_return_value = runner.schema.sync_lazy(is_authed)
+        end
+
+        result = if is_authed
+          Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
+          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 GraphQL::UnauthorizedError => auth_err
+        exec_result[exec_index] = begin
+          context.schema.unauthorized_object(auth_err)
+        rescue GraphQL::ExecutionError => exec_err
+          exec_err
+        end
+      rescue GraphQL::RuntimeError => err
+        exec_result[exec_index] = err
+      rescue StandardError => stderr
+        exec_result[exec_index] = begin
+          context.query.handle_or_reraise(stderr)
+        rescue GraphQL::ExecutionError => ex_err
+          ex_err
+        end
+      ensure
+        field_pending_steps = field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if field_pending_steps.size == 0 && field_resolve_step.field_results
+          field_resolve_step.runner.add_step(field_resolve_step)
+        end
+      end
+
       def arguments
         @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
       end
@@ -154,6 +225,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
@@ -32,14 +30,47 @@ module GraphQL
         end
       end
 
+      # @api private
+      def call_resolve(args_hash)
+        if @field_resolve_step.nil?
+          super
+        else
+          context.namespace(:subscriptions)[:update_event] = event
+          result = nil
+          unsubscribed = true
+          unsubscribed_result = nil
+          begin
+            result = super
+            unsubscribed = false
+          rescue EarlyUnsubscribe => err
+            unsubscribed_result = err.unsubscribed_result
+          end
+
+
+          if unsubscribed
+            if unsubscribed_result
+              context.namespace(:subscriptions)[:final_update] = true
+              unsubscribed_result
+            else
+              context.skip
+            end
+          else
+            result
+          end
+        end
+      end
+
       # @api private
       def resolve_with_support(**args)
         @original_arguments = args # before `loads:` have been run
         result = nil
         unsubscribed = true
-        unsubscribed_result = catch :graphql_subscription_unsubscribed do
+        unsubscribed_result = nil
+        begin
           result = super
           unsubscribed = false
+        rescue EarlyUnsubscribe => err
+          unsubscribed_result = err.unsubscribed_result
         end
 
 
@@ -116,7 +147,13 @@ module GraphQL
       # @return [void]
       def unsubscribe(update_value = nil)
         context.namespace(:subscriptions)[:unsubscribed] = true
-        throw :graphql_subscription_unsubscribed, update_value
+        err = EarlyUnsubscribe.new
+        err.unsubscribed_result = update_value
+        raise err
+      end
+
+      class EarlyUnsubscribe < GraphQL::RuntimeError
+        attr_accessor :unsubscribed_result
       end
 
       # Call this method to provide a new subscription_scope; OR
@@ -189,12 +226,18 @@ module GraphQL
 
       # @return [Subscriptions::Event] This object is used as a representation of this subscription for the backend
       def event
-        @event ||= Subscriptions::Event.new(
-          name: field.name,
-          arguments: @original_arguments,
-          context: context,
-          field: field,
-        )
+        @event ||= begin
+          if @original_arguments.nil? && @field_resolve_step
+            @original_arguments, _errors = @field_resolve_step.arguments_without_loads
+          end
+
+          Subscriptions::Event.new(
+            name: field.name,
+            arguments: @original_arguments,
+            context: context,
+            field: field,
+          )
+        end
       end
     end
   end

data/lib/graphql/schema/timeout.rb

@@ -68,7 +68,7 @@ module GraphQL
           super
         end
 
-        def execute_field(query:, field:, **_rest)
+        def begin_execute_field(field, _arguments, _objects, query)
           timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
           if timeout_state == false
@@ -84,7 +84,7 @@ module GraphQL
 
             # `handle_timeout` may have set this to be `false`
             if timeout_state != false
-              error
+              raise error
             else
               super
             end

data/lib/graphql/schema/validator/allow_blank_validator.rb

@@ -8,7 +8,7 @@ module GraphQL
       # @example Require a non-empty string for an argument
       #   argument :name, String, required: true, validate: { allow_blank: false }
       class AllowBlankValidator < Validator
-        def initialize(allow_blank_positional, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
+        def initialize(allow_blank_positional = nil, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
           @message = message
           super(**default_options)
           @allow_blank = allow_blank.nil? ? allow_blank_positional : allow_blank
@@ -16,10 +16,10 @@ module GraphQL
 
         def validate(_object, _context, value)
           if value.respond_to?(:blank?) && value.blank?
-            if (value.nil? && @allow_null) || @allow_blank
+            if (value.nil? && validation_parameter(@allow_null)) || validation_parameter(@allow_blank)
               # pass
             else
-              @message
+              validation_parameter(@message)
             end
           end
         end

data/lib/graphql/schema/validator/allow_null_validator.rb

@@ -9,15 +9,15 @@ module GraphQL
       #   argument :name, String, required: false, validates: { allow_null: false }
       class AllowNullValidator < Validator
         MESSAGE = "%{validated} can't be null"
-        def initialize(allow_null_positional, allow_null: nil, message: MESSAGE, **default_options)
+        def initialize(allow_null_positional = nil, allow_null: nil, message: MESSAGE, **default_options)
           @message = message
           super(**default_options)
           @allow_null = allow_null.nil? ? allow_null_positional : allow_null
         end
 
         def validate(_object, _context, value)
-          if value.nil? && !@allow_null
-            @message
+          if value.nil? && !validation_parameter(@allow_null)
+            validation_parameter(@message)
           end
         end
       end

data/lib/graphql/schema/validator/exclusion_validator.rb

@@ -23,8 +23,8 @@ module GraphQL
         def validate(_object, _context, value)
           if permitted_empty_value?(value)
             # pass
-          elsif @in_list.include?(value)
-            @message
+          elsif validation_parameter(@in_list).include?(value)
+            validation_parameter(@message)
           end
         end
       end

data/lib/graphql/schema/validator/format_validator.rb

@@ -37,9 +37,9 @@ module GraphQL
           if permitted_empty_value?(value)
             # Do nothing
           elsif value.nil? ||
-              (@with_pattern && !value.match?(@with_pattern)) ||
-              (@without_pattern && value.match?(@without_pattern))
-            @message
+              (@with_pattern && !value.match?(validation_parameter(@with_pattern))) ||
+              (@without_pattern && value.match?(validation_parameter(@without_pattern)))
+            validation_parameter(@message)
           end
         end
       end

data/lib/graphql/schema/validator/inclusion_validator.rb

@@ -25,8 +25,8 @@ module GraphQL
         def validate(_object, _context, value)
           if permitted_empty_value?(value)
             # pass
-          elsif !@in_list.include?(value)
-            @message
+          elsif !validation_parameter(@in_list).include?(value)
+            validation_parameter(@message)
           end
         end
       end

data/lib/graphql/schema/validator/length_validator.rb

@@ -45,12 +45,12 @@ module GraphQL
         def validate(_object, _context, value)
           return if permitted_empty_value?(value) # pass in this case
           length = value.nil? ? 0 : value.length
-          if @maximum && length > @maximum
-            partial_format(@too_long, { count: @maximum })
-          elsif @minimum && length < @minimum
-            partial_format(@too_short, { count: @minimum })
-          elsif @is && length != @is
-            partial_format(@wrong_length, { count: @is })
+          if (current_max = validation_parameter(@maximum)) && length > current_max
+            partial_format(validation_parameter(@too_long), { count: current_max })
+          elsif (current_min = validation_parameter(@minimum)) && length < current_min
+            partial_format(validation_parameter(@too_short), { count: current_min })
+          elsif (current_is = validation_parameter(@is)) && length != current_is
+            partial_format(validation_parameter(@wrong_length), { count: current_is })
           end
         end
       end

data/lib/graphql/schema/validator/numericality_validator.rb

@@ -55,25 +55,25 @@ module GraphQL
           if permitted_empty_value?(value)
             # pass in this case
           elsif value.nil? # @allow_null is handled in the parent class
-            @null_message
-          elsif @greater_than && value <= @greater_than
-            partial_format(@message, { comparison: "greater than", target: @greater_than })
-          elsif @greater_than_or_equal_to && value < @greater_than_or_equal_to
-            partial_format(@message, { comparison: "greater than or equal to", target: @greater_than_or_equal_to })
-          elsif @less_than && value >= @less_than
-            partial_format(@message, { comparison: "less than", target: @less_than })
-          elsif @less_than_or_equal_to && value > @less_than_or_equal_to
-            partial_format(@message, { comparison: "less than or equal to", target: @less_than_or_equal_to })
-          elsif @equal_to && value != @equal_to
-            partial_format(@message, { comparison: "equal to", target: @equal_to })
-          elsif @other_than && value == @other_than
-            partial_format(@message, { comparison: "something other than", target: @other_than })
-          elsif @even && !value.even?
-            (partial_format(@message, { comparison: "even", target: "" })).strip
-          elsif @odd && !value.odd?
-            (partial_format(@message, { comparison: "odd", target: "" })).strip
-          elsif @within && !@within.include?(value)
-            partial_format(@message, { comparison: "within", target: @within })
+            validation_parameter(@null_message)
+          elsif (current_greater_than = validation_parameter(@greater_than)) && value <= current_greater_than
+            partial_format(validation_parameter(@message), { comparison: "greater than", target: current_greater_than })
+          elsif (current_greater_than_or_equal_to = validation_parameter(@greater_than_or_equal_to)) && value < current_greater_than_or_equal_to
+            partial_format(validation_parameter(@message), { comparison: "greater than or equal to", target: current_greater_than_or_equal_to })
+          elsif (current_less_than = validation_parameter(@less_than)) && value >= current_less_than
+            partial_format(validation_parameter(@message), { comparison: "less than", target: current_less_than })
+          elsif (current_less_than_or_equal_to = validation_parameter(@less_than_or_equal_to)) && value > current_less_than_or_equal_to
+            partial_format(validation_parameter(@message), { comparison: "less than or equal to", target: current_less_than_or_equal_to })
+          elsif (current_equal_to = validation_parameter(@equal_to)) && value != current_equal_to
+            partial_format(validation_parameter(@message), { comparison: "equal to", target: current_equal_to })
+          elsif (current_other_than = validation_parameter(@other_than)) && value == current_other_than
+            partial_format(validation_parameter(@message), { comparison: "something other than", target: current_other_than })
+          elsif validation_parameter(@even) && !value.even?
+            (partial_format(validation_parameter(@message), { comparison: "even", target: "" })).strip
+          elsif validation_parameter(@odd) && !value.odd?
+            (partial_format(validation_parameter(@message), { comparison: "odd", target: "" })).strip
+          elsif (current_within = validation_parameter(@within)) && !current_within.include?(value)
+            partial_format(validation_parameter(@message), { comparison: "within", target: current_within })
           end
         end
       end

data/lib/graphql/schema/validator/required_validator.rb

@@ -8,6 +8,13 @@ module GraphQL
       #
       # (This is for specifying mutually exclusive sets of arguments.)
       #
+      # If you use {GraphQL::Schema::Visibility} to hide all the arguments in a `one_of: [..]` set,
+      # then a developer-facing {GraphQL::Error} will be raised during execution. Pass `allow_all_hidden: true` to
+      # skip validation in this case instead.
+      #
+      # This validator also implements `argument ... required: :nullable`. If an argument has `required: :nullable`
+      # but it's hidden with {GraphQL::Schema::Visibility}, then this validator doesn't run.
+      #
       # @example Require exactly one of these arguments
       #
       #   field :update_amount, IngredientAmount, null: false do
@@ -37,15 +44,17 @@ module GraphQL
       class RequiredValidator < Validator
         # @param one_of [Array<Symbol>] A list of arguments, exactly one of which is required for this field
         # @param argument [Symbol] An argument that is required for this field
+        # @param allow_all_hidden [Boolean] If `true`, then this validator won't run if all the `one_of: ...` arguments have been hidden
         # @param message [String]
-        def initialize(one_of: nil, argument: nil, message: nil, **default_options)
+        def initialize(one_of: nil, argument: nil, allow_all_hidden: nil, message: nil, **default_options)
           @one_of = if one_of
             one_of
           elsif argument
-            [argument]
+            [ argument ]
           else
             raise ArgumentError, "`one_of:` or `argument:` must be given in `validates required: {...}`"
           end
+          @allow_all_hidden = allow_all_hidden.nil? ? !!argument : allow_all_hidden
           @message = message
           super(**default_options)
         end
@@ -54,10 +63,18 @@ module GraphQL
           fully_matched_conditions = 0
           partially_matched_conditions = 0
 
+          visible_keywords = context.types.arguments(@validated).map(&:keyword)
+          no_visible_conditions = true
+
           if !value.nil?
-            @one_of.each do |one_of_condition|
+            validation_parameter(@one_of).each do |one_of_condition|
+              one_of_condition = validation_parameter(one_of_condition)
               case one_of_condition
               when Symbol
+                if no_visible_conditions && visible_keywords.include?(one_of_condition)
+                  no_visible_conditions = false
+                end
+
                 if value.key?(one_of_condition)
                   fully_matched_conditions += 1
                 end
@@ -66,6 +83,9 @@ module GraphQL
                 full_match = true
 
                 one_of_condition.each do |k|
+                  if no_visible_conditions && visible_keywords.include?(k)
+                    no_visible_conditions = false
+                  end
                   if value.key?(k)
                     any_match = true
                   else
@@ -88,10 +108,22 @@ module GraphQL
             end
           end
 
+          if no_visible_conditions
+            if validation_parameter(@allow_all_hidden)
+              return nil
+            else
+              raise GraphQL::Error, <<~ERR
+                #{@validated.path} validates `required: ...` but all required arguments were hidden.
+
+                Update your schema definition to allow the client to see some fields or skip validation by adding `required: { ..., allow_all_hidden: true }`
+              ERR
+            end
+          end
+
           if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else
-            @message || build_message(context)
+            validation_parameter(@message) || build_message(context)
           end
         end
 
@@ -99,8 +131,9 @@ module GraphQL
           argument_definitions = context.types.arguments(@validated)
 
           required_names = @one_of.map do |arg_keyword|
+            arg_keyword = validation_parameter(arg_keyword)
             if arg_keyword.is_a?(Array)
-              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
+              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, validation_parameter(arg)) }
               names.compact! # hidden arguments are `nil`
               "(" + names.join(" and ") + ")"
             else

data/lib/graphql/schema/validator.rb

@@ -34,6 +34,15 @@ module GraphQL
         string
       end
 
+      # @return [Object] The current value to use for validation, based on `config_value` from configuration time. If a Proc is given, this calls it and returns it.
+      def validation_parameter(config_value)
+        if config_value.is_a?(Proc)
+          config_value.call
+        else
+          config_value
+        end
+      end
+
       # @return [Boolean] `true` if `value` is `nil` and this validator has `allow_null: true` or if value is `.blank?` and this validator has `allow_blank: true`
       def permitted_empty_value?(value)
         (value.nil? && @allow_null) ||

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)
@@ -325,11 +290,13 @@ module GraphQL
             end
             # Lots more to do here
           end
-          @schema.introspection_system.entry_points.each do |f|
-            arguments(f).each do |arg|
-              argument(f, arg.graphql_name)
+          if @schema.query
+            @schema.introspection_system.entry_points.each do |f|
+              arguments(f).each do |arg|
+                argument(f, arg.graphql_name)
+              end
+              field(@schema.query, f.graphql_name)
             end
-            field(@schema.query, f.graphql_name)
           end
           @schema.introspection_system.dynamic_fields.each do |f|
             arguments(f).each do |arg|
@@ -341,6 +308,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/visibility/visit.rb

@@ -102,7 +102,7 @@ module GraphQL
 
             missed_late_types_streak = 0
             while (owner, late_type = @late_bound_types.shift)
-              if (late_type.is_a?(String) && (type = Member::BuildType.constantize(type))) ||
+              if (late_type.is_a?(String) && (type = Member::BuildType.constantize(late_type))) ||
                   (late_type.is_a?(LateBoundType) && (type = @visited_types.find { |t| t.graphql_name == late_type.graphql_name }))
                 missed_late_types_streak = 0 # might succeed next round
                 update_type_owner(owner, type)